# Add and verify a domain
Source: https://resend.com/docs/add-a-domain

Get started sending emails by adding a domain to your account.

Resend sends emails using a domain you own. Before you can send or receive emails with Resend, you must have a verified domain associated with your account.

> [!NOTE]
>
> If you don't own a domain, please purchase one from a domain registrar such as
> [Cloudflare](https://www.cloudflare.com/) or
> [Namecheap](https://www.namecheap.com/) before continuing.

## Add a domain

You can add and verify a domain you own in four ways:

* in the [**Domains** Dashboard page](/docs/dashboard/domains/introduction)
* using the [Resend API](/docs/api-reference/domains/create-domain)
* with a [Resend CLI command](/docs/cli#domains)
* with the [Resend MCP server](/docs/mcp-server)

To add a new domain from the Resend Dashboard:

**1. In your Resend Dashboard, navigate to the Domains page.**

**2. Click the Add Domain button.**

**3. Enter a domain including a subdomain to use for your Resend emails.**

We strongly recommend sending emails from a subdomain (e.g., `notifications.example.com`) instead of your root domain (`example.com`) to conform to deliverability best practices.

Choose a subdomain that reflects the purpose of your emails, such as `customers.example.com` or `updates.example.com`.

You can have multiple subdomains associated with your root domain. But, each one must be configured and verified individually.

If you add a domain already used by another team, the dashboard will notify you and you can [claim the domain](/docs/dashboard/domains/claim) to transfer it to your team.

**4. Choose a region from the list provided.**

Select a region to send your emails from. Choose one that is closest to the majority of your recipients.

**5. (optional) Enter a custom subdomain for the Return-Path address if desired.**

Return-Path defaults to `send.example.com`, although you can [provide a custom path](/docs/dashboard/domains/custom-return-path).

**6. Update your DNS records with values provided by Resend.**

View the **Records** tab for your domain to find the records to provide to your DNS host provider. Adding these records will verify that you own the domain and have the correct permissions to send and receive emails.

Provide the DKIM and SPF configurations (`TXT` and `MX` or `CNAME` records) to your DNS provider. These records must match exactly what Resend generated. Copy and paste the records to avoid configuration errors.

> [!TIP]
>
> Consult one of our [DNS provider guides](/docs/knowledge-base/introduction) for specific examples of updating your DNS records with your host. Also, when shown a CNAME, make sure *not* to use proxying features (e.g., Cloudflare's orange cloud) for that record, as it will prevent verification from completing.

**7. Wait for DNS verification to complete**

When this process is completed correctly, your domain will often verify within 15 minutes of adding the DNS records. However, DNS changes can occasionally take up to 72 hours to propagate globally.

You can use Resend's [dns.email tool](https://dns.email/) to check that your records are visible publicly. If verification has not completed after 72 hours, use the “Restart verification” button in the Resend dashboard to trigger a fresh verification check.

**8. Add a DMARC record.**

After your domain is verified, you can then [implement DMARC](/docs/dashboard/domains/dmarc) to build additional trust in your domain and protect against email spoofing.

This is an email authentication protocol to verify email senders and to allow receivers to reject unauthenticated messages, and is important for email deliverability.

**9. (optional) Update your domain's Resend configuration options.**

After your domain is verified, you may wish to [enable open and click tracking](/docs/dashboard/domains/tracking) or [enforce Transport Layer Security (TLS)](/docs/dashboard/domains/tls).

## Learn more

> [card] [Manage domains](/docs/dashboard/domains/introduction)
>
> View, create, edit, delete, and manage your domains.

> [card] [Multi-tenant domain setup](/docs/knowledge-base/setting-up-resend-for-multi-tenants)
>
> Learn how to configure Resend for SaaS platforms where tenants send emails
> from their own domains.

## Next steps

> [card] [Add a DMARC record](/docs/dashboard/domains/dmarc)
>
> Implement DMARC to build trust in your domain and protect against email
> spoofing.

> [card] [Quickstart tutorials](/docs/introduction)
>
> Send your first transactional email with a quick tutorial for your language
> or framework.


# Agent Email Inbox Skill
Source: https://resend.com/docs/agent-email-inbox-skill

Give your AI agent a secure email inbox to receive and act on inbound emails.

The Agent Email Inbox skill enables AI agents to securely receive and respond to emails through a Resend [Inbox](/docs/api-reference/inboxes/create-inbox). It provides security patterns that prevent untrusted email content from controlling your agent, including sender allowlists, content filtering, and sandboxed processing.

The inbox groups each conversation into a thread, and your agent replies in the thread with one call. Without a custom domain, or when your plan has no inbox available, the skill falls back to [Receiving](/docs/dashboard/receiving/introduction) with the same security levels.

## Why your agent needs a secure inbox

An AI agent's inbox receives **untrusted input**. Without proper security, anyone who knows your agent's email address can send instructions that your agent will execute. The Agent Email Inbox skill solves this with a leveled security approach built in from the start.

Unlike polling-based approaches, Resend uses **webhooks** for inbound email. Your agent is notified instantly when an email arrives. No cron jobs, no wasted API calls checking empty inboxes.

## Installation

This skill is part of the [resend-skills](https://github.com/resend/resend-skills) repository, which also includes the [Resend skill](/docs/resend-skill) for sending emails. When you run the install command, you'll be prompted to choose which skills to install.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
```

## Advantages

* **5 security levels**: From strict sender allowlists to human-in-the-loop approval, choose the right level of security for your use case.
* **Real-time webhook architecture**: Event-driven design means your agent reacts to emails in seconds, not minutes.
* **Threaded replies**: Your agent replies inside the conversation, and Resend sets the recipients and threading headers.
* **Webhook signature verification**: Built-in patterns for verifying Resend webhook signatures to prevent spoofed events.
* **Multi-language SDK support**: The inbox examples use the Node.js SDK. The Receiving fallback works with Node.js, Python, Go, Ruby, PHP, Rust, Java, and .NET.
* **Common threat protection**: Built-in guidance for handling prompt injection, sender spoofing, and email flooding.

## Architecture

```
Email → Resend Inbox → Webhook → Your Server → Validate
                                                   ↓
                                   Process or Reject → Reply in the thread
```

Your agent only processes emails that pass your chosen security level. Rejected emails are logged and silently acknowledged to prevent retries.

## Security Levels

Choose a security level before setting up your webhook endpoint. Start with **Level 1** and relax only if needed.

| Level | Name | Best For |
| - | - | - |
| **1** | Strict Allowlist | Most use cases, only process emails from known senders |
| **2** | Domain Allowlist | Organization-wide access from trusted domains |
| **3** | Content Filtering | Accept from anyone, but filter unsafe patterns |
| **4** | Sandboxed Processing | Process all emails with restricted agent capabilities |
| **5** | Human-in-the-Loop | Require human approval for actions from untrusted senders |

Each level includes full implementation code in the skill. After installation, your AI agent will have access to the detailed security patterns and can help you implement the right level.

## Example

A minimal webhook handler that verifies the signature, checks the sender against an allowlist, retrieves the full email, and replies in its thread:

```js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);
const ALLOWED_SENDERS = ['your@email.com'];

// `from` can be `Name <address>`, so compare the address only
const senderAddress = (from) => {
  const match = from.match(/<([^<>]+)>\s*$/);
  return (match ? match[1] : from).trim().toLowerCase();
};

async function handler(req) {
  const payload = await req.text();

  const event = resend.webhooks.verify({
    payload,
    headers: {
      id: req.headers.get('svix-id'),
      timestamp: req.headers.get('svix-timestamp'),
      signature: req.headers.get('svix-signature'),
    },
    webhookSecret: process.env.RESEND_WEBHOOK_SECRET,
  });

  if (event.type === 'inbox.email.received') {
    const { inbox_id, thread_id, email_id, email } = event.data;

    if (!email || !ALLOWED_SENDERS.includes(senderAddress(email.from))) {
      return new Response('OK', { status: 200 });
    }

    const thread = {
      inboxId: inbox_id,
      threadId: thread_id,
      emailId: email_id,
    };
    const { data: fullEmail } = await resend.inboxes.threads.emails.get(thread);

    const answer = await processEmailForAgent(fullEmail);

    await resend.inboxes.threads.emails.reply({ ...thread, text: answer });
  }

  return new Response('OK', { status: 200 });
}
```

The inbox methods need `resend` 6.34.1 or later.

## Learn More

> [card] [OpenClaw Setup Guide](/docs/openclaw-guide)
>
> Step-by-step guide for giving an OpenClaw agent a fully functional email
> inbox.

> [card] [View on GitHub](https://github.com/resend/resend-skills/tree/main/skills/agent-email-inbox)
>
> See the full source code, security patterns, and documentation.


# AI onboarding
Source: https://resend.com/docs/ai-onboarding

Everything you need to onboard your AI agent to Resend.

If you're developing with AI, Resend offers several resources to improve your experience.

* [Resend MCP Server](#resend-mcp-server)
* [Resend CLI](#resend-cli)
* [Resend Docs for Agents](#resend-docs-for-agents)
* [Email Skills for Agents](#email-skills-for-agents)
* [Quick Start Guides](#quick-start-guides)
* [OpenClaw Guide](#openclaw-guide)
* [Chat SDK](#chat-sdk)
* [AI Builder Guides](#ai-builder-guides)
* [AI Integrations](#ai-integrations)

## Prerequisite: Create an API Key

A human must create the Resend account. Once you have an account, you'll need to [create an API key](/docs/create-an-api-key). With an API key, your agent can perform many other tasks.

> [!NOTE]
>
> To send or receive with Resend, you'll need to [verify a domain](https://resend.com/domains). While an agent can [create a domain](/docs/api-reference/domains/create-domain), the API returns DNS records you will need to add in your DNS provider before [verifying your DNS records](/docs/api-reference/domains/verify-domain). You may find it easier to verify your domain in the dashboard.

## Resend MCP Server

MCP is an open protocol that standardizes how applications provide context to LLMs. Among other benefits, it provides LLMs tools to act on your behalf. Our [MCP server](https://github.com/resend/resend-mcp) is open-source and covers our full API surface area.

Resend hosts the MCP server, so you can connect any MCP client without installing anything:

```
https://mcp.resend.com/mcp
```

When you connect, your client authenticates with OAuth by opening a browser to log in to Resend. Clients that can't complete a browser login can pass an API key as a Bearer token instead. You can also run the server locally with `npx` using the `resend-mcp` package on NPM.

The [Resend plugin](https://github.com/resend/resend-skills) follows the [Agent Plugins](https://agent-plugins.org) spec. On clients whose landing page installs that plugin, it adds the remote MCP server and the Resend skills together. Setup for each client is on the [MCP server page](/docs/mcp-server), and it matches the page at resend.com. Claude and Codex also keep these one-click installs:

* [Resend connector for Claude](https://claude.ai/directory/connectors/resend)
* [Resend plugin for Codex](https://chatgpt.com/plugins/plugin_asdk_app_6a3c407853888191beddc2151c2b6f8b?open_in_codex)

> [card] [MCP Server](/docs/mcp-server)
>
> View setup instructions for Claude, Cursor, Codex, Copilot, Hermes, OpenClaw,
> and more.

## Resend CLI

The Resend CLI lets you send emails, manage your account, and develop locally, all from the terminal. It's built for humans, AI agents, and CI/CD pipelines.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
# Authenticate
resend login

# Send an email
resend emails send \
  --from "you@example.com" \
  --to hello@example.com \
  --subject "Hello" \
  --text "Sent from my terminal."
```

The CLI also includes a full local webhook setup for developing with inbound email events without deploying anything.

> [card] [Resend CLI](/docs/cli)
>
> Install the CLI and set up a local webhook development environment.

## Resend Docs for Agents

You can give your agent current docs in a context-aware way in three ways:

1. **Markdown docs**

   Every doc includes a markdown version (append `md` to any page)

   ```
   Docs for this page: https://resend.com/docs/ai-onboarding.md
   ```

2. **Full llms.txt**

   Give your agent all our docs in a single file.

   ```
   Here are the Resend docs: https://resend.com/docs/llms-full.txt
   ```

3. **MCP Docs server**

   For a more structured approach using MCP tools, you can install our MCP docs server in any MCP client, like Cursor, Codex, or Claude Code.

   ```
   npx add-mcp https://resend.com/docs/mcp
   ```

## Email Skills for Agents

Skills give AI agents specialized knowledge for specific tasks.

Install skills with a single command:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
```

Or install individually:

| Skill | Install | What it does |
| - | - | - |
| [Resend](/docs/resend-skill) | `npx skills add resend/resend-skills` | Send and receive emails, handle errors, and prevent duplicate sends. Get code examples from various SDKs. |
| [React Email](/docs/react-email-skill) | `npx skills add resend/react-email` | Build emails in React, Tailwind, and TypeScript. Audit existing React emails for style and cross-client rendering. |
| [Email Best Practices](/docs/email-best-practices-skill) | `npx skills add resend/email-best-practices` | Audit SPF/DKIM/DMARC setup, compliance (CAN-SPAM, GDPR), webhook handling |

## Quick Start Guides

The documentation includes quick start guides for common tasks with Resend. They contain step-by-step instructions for sending emails, creating templates, and more. Copy the prompt for your agent or click to open in Cursor.

Example agent quick start guide for sending emails.

Resend provides two endpoints for sending emails:

| Approach | Endpoint | Use Case |
| - | - | - |
| **Single** | `POST /emails` | Individual transactional emails, emails with attachments, scheduled sends |
| **Batch** | `POST /emails/batch` | Multiple distinct emails in one request (max 100), bulk notifications |

**Choose batch when:**

* Sending 2+ distinct emails at once
* Reducing API calls is important (by default, rate limit is 10 requests per second)
* No attachments or scheduling needed

**Choose single when:**

* Sending one email
* Email needs attachments
* Email needs to be scheduled
* Different recipients need different timing

## Quick Start

1. **Detect project language** from config files (package.json, requirements.txt, go.mod, etc.)
2. **Install SDK** (preferred) or use cURL
3. **Choose single or batch** based on the decision matrix above
4. **Implement best practices** - Idempotency keys, error handling, retries

## Best Practices (Critical for Production)

Always implement these for production email sending.

### Idempotency Keys

Prevent duplicate emails when retrying failed requests.

| Key Facts | |
| - | - |
| **Format (single)** | `<event-type>/<entity-id>` (e.g., `welcome-email/user-123`) |
| **Format (batch)** | `batch-<event-type>/<batch-id>` (e.g., `batch-orders/batch-456`) |
| **Expiration** | 24 hours |
| **Max length** | 256 characters |
| **Duplicate payload** | Returns original response without resending |
| **Different payload** | Returns 409 error |

### Error Handling

| Code | Action |
| - | - |
| 400, 422 | Fix request parameters, don't retry |
| 401, 403 | Check API key / verify domain, don't retry |
| 409 | Idempotency conflict - use new key or fix payload |
| 429 | Rate limited - retry with exponential backoff (by default, rate limit is 10 requests/second) |
| 500 | Server error - retry with exponential backoff |

### Retry Strategy

* **Backoff:** Exponential (1s, 2s, 4s...)
* **Max retries:** 3-5 for most use cases
* **Only retry:** 429 (rate limit) and 500 (server error)
* **Always use:** Idempotency keys when retrying

## Single Email

**Endpoint:** `POST /emails` (prefer SDK over cURL)

### Required Parameters

| Parameter | Type | Description |
| - | - | - |
| `from` | string | Sender address. Format: `"Name <email@domain.com>"` |
| `to` | string\[] | Recipient addresses (max 50) |
| `subject` | string | Email subject line |
| `html` or `text` | string | Email body content |

### Optional Parameters

| Parameter | Type | Description |
| - | - | - |
| `cc` | string\[] | CC recipients |
| `bcc` | string\[] | BCC recipients |
| `reply_to`\* | string\[] | Reply-to addresses |
| `scheduled_at`\* | string | Schedule send time (ISO 8601) |
| `attachments` | array | File attachments (max 40MB total) |
| `tags` | array | Key/value pairs for tracking |
| `headers` | object | Custom headers |

\*Parameter naming varies by SDK (e.g., `replyTo` in Node.js, `reply_to` in Python).

### Minimal Example (Node.js)

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send(
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Hello World',
    html: '<p>Email body here</p>',
  },
  { idempotencyKey: `welcome-email/${userId}` },
);

if (error) {
  console.error('Failed:', error.message);
  return;
}
console.log('Sent:', data.id);
```

## Batch Email

**Endpoint:** `POST /emails/batch` (but prefer SDK over cURL)

### Limitations

* **No attachments** - Use single sends for emails with attachments
* **No scheduling** - Use single sends for scheduled emails
* **Atomic** - If one email fails validation, the entire batch fails
* **Max 100 emails** per request
* **Max 50 recipients** per individual email in the batch

### Pre-validation

Since the entire batch fails on any validation error, validate all emails before sending:

* Check required fields (from, to, subject, html/text)
* Validate email formats
* Ensure batch size is less than or equal to 100

### Minimal Example (Node.js)

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.batch.send(
  [
    {
      from: 'Acme <hello@example.com>',
      to: ['delivered@resend.dev'],
      subject: 'Order Shipped',
      html: '<p>Your order has shipped!</p>',
    },
    {
      from: 'Acme <hello@example.com>',
      to: ['delivered@resend.dev'],
      subject: 'Order Confirmed',
      html: '<p>Your order is confirmed!</p>',
    },
  ],
  { idempotencyKey: `batch-orders/${batchId}` },
);

if (error) {
  console.error('Batch failed:', error.message);
  return;
}
console.log(
  'Sent:',
  data.map((e) => e.id),
);
```

## OpenClaw Guide

Equipping your agent with its own email inbox can be a powerful tool to unlock new workflows. Alternatively, give it access to your Resend account to support agentic flows for sending and receiving emails.

> [card] [Email Automation for OpenClaw using Resend](/docs/openclaw-guide)
>
> View the OpenClaw guide.

## Chat SDK

The `@resend/chat-sdk-adapter` package is a Vercel Chat SDK adapter that turns email into a two-way communication channel. Receive inbound emails through webhooks, reply through the Resend API, and let the adapter handle threading automatically. It also supports card emails, attachments, and proactive outreach.

> [card] [Chat SDK](/docs/chat-sdk)
>
> Build conversational email experiences with the Chat SDK adapter.

## AI Builder Guides

Get started using Resend with popular AI builders:

* [Anything Integration](/docs/anything-integration)
* [Lovable Integration](/docs/lovable-integration)
* [v0 Integration](/docs/v0-integration)
* [Bolt.new Integration](/docs/bolt-new-integration)
* [Replit Integration](/docs/replit-integration)
* [Base44 Integration](/docs/base44-integration)
* [Leap.new Integration](/docs/leap-new-integration)

## AI Integrations

Several AI tools have created integrations for working with Resend. Visit their documentation for information on integrating Resend with their tools.

> [card] [Lovable](https://docs.lovable.dev/integrations/resend)
>
> Tell the Lovable AI to send emails

> [card] [Anything](https://www.createanything.com/docs/integrations/resend)
>
> Add email to your Anything projects

> [card] [Wildcard](https://github.com/wild-card-ai/agents-json/blob/master/examples/resend.ipynb)
>
> Send natural language emails using Wildcard

> [card] [mcp.run](https://www.mcp.run/nilslice/resend)
>
> Build email AI agents using mcp.run

> [card] [Rocket](https://docs.rocket.new/integrations/resend)
>
> Send emails from apps built with Rocket

> [card] [Base44](https://docs.base44.com/Integrations/Resend-integration)
>
> Add email to your Base44 apps

> [card] [Leap.new](https://docs.leap.new/integrations/resend)
>
> Add email to your Leap apps

> [card] [Parsley](https://www.parsley.id/integrations/resend)
>
> Send alerts and follow-ups with Parsley

> [card] [Pica](https://www.picaos.com/integrations/resend)
>
> Integrate Pica with Resend


# How to add the Resend integration to your Anything project
Source: https://resend.com/docs/anything-integration

Learn how to add the Resend integration to your Anything project.

[Anything](https://createanything.com) is a platform for building web sites, tools, apps, and projects via chat. With their [Resend integration](https://www.createanything.com/docs/integrations/resend), you can send emails from your Anything project.

If you prefer to watch a video, check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/Avp1OOMH2Z0)

## Guide

**1. Call the Resend integration in Anything**

Type `/Resend` in the chat and select the integration, and ask Anything to add email functionality to your project.

![adding the Resend integration to a Anything chat](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/create-xyz-integration.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=810ab7bd912d16365530bbda50d339d8)

**2. Add your Resend API key**

Anything usually prompts you for a Resend API key, which you can add in the [Resend Dashboard](https://resend.com/api-keys). If Anything doesn't prompt you for a Resend API key, click the **More options**  button and select **Secrets**.

Click the  **Add new secret** button.

* **Name:** `RESEND_API_KEY`
* **Value:** Your Resend API key (e.g., `re_xxxxxxxxx0`)

Learn more about [Secrets in Create](https://www.createanything.com/docs/essentials#project-settings).

**3. Add a custom domain to your Resend account**

By default, you can only send emails to your own email address.

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](https://resend.com/domains).
2. Add the custom domain to the `from` field in the `resend` function in Create.

Learn more about [Functions in Create](https://www.createanything.com/docs/builder/functions).


# Create API key
Source: https://resend.com/docs/api-reference/api-keys/create-api-key

POST /api-keys
Add a new API key to authenticate communications with Resend.

## Body Parameters

**name** `string` *required*

The API key name. Maximum 50 characters.

**permission** `full_access | sending_access`

The API key can have full access to Resend's API or be only restricted to send emails.

* `full_access`: Can create, delete, get, and update any resource.
* `sending_access`: Can only send emails. For Inboxes, it can call only [Reply to Thread Email](/docs/api-reference/inboxes/reply-thread-email), [Forward Thread Email](/docs/api-reference/inboxes/forward-thread-email), [Create Draft](/docs/api-reference/inboxes/create-draft) and [Send Draft](/docs/api-reference/inboxes/send-draft). A key restricted to a domain can use only the inboxes on that domain.

Restrict an API key to send emails only from a specific domain. This is only
used when the `permission` is set to `sending_access`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.apiKeys.create({ name: 'Production' });
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->apiKeys->create([
  'name' => 'Production'
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.ApiKeys.CreateParams = {
  "name": "Production",
}

resend.ApiKeys.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "Production"
}
Resend::ApiKeys.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")
	params := &resend.CreateApiKeyRequest{
		Name: "Production",
	}
	client.ApiKeys.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateApiKeyOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _api_key = resend
    .api_keys
    .create(CreateApiKeyOptions::new("Production"))
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.apikeys.model.CreateApiKeyOptions;
import com.resend.services.apikeys.model.CreateApiKeyResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateApiKeyOptions params = CreateApiKeyOptions
                .builder()
                .name("Production").build();

        CreateApiKeyResponse apiKey = resend.apiKeys().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ApiKeyCreateAsync( "Production" );
Console.WriteLine( "Token={0}", resp.Content.Token );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/api-keys' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Production"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend api-keys create --name Production
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "dacf4072-4119-4d88-932f-6202748ac7c8",
  "object": "api_key",
  "token": "re_c1tpEyD8_NKFusih9vKVQknRAQfmFcWCv"
}
```


# Delete API key
Source: https://resend.com/docs/api-reference/api-keys/delete-api-key

DELETE /api-keys/:api_key_id
Remove an existing API key.

## Path Parameters

The API key ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.apiKeys.remove(
  'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->apiKeys->remove('b6d24b8e-af0b-4c3c-be0c-359bbd97381e');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"
resend.ApiKeys.remove(api_key_id="b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::ApiKeys.remove "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")
	client.ApiKeys.Remove("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  resend
    .api_keys
    .delete("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        resend.apiKeys().remove("b6d24b8e-af0b-4c3c-be0c-359bbd97381e");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.ApiKeyDeleteAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/api-keys/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend api-keys delete b6d24b8e-af0b-4c3c-be0c-359bbd97381e
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "api_key",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  "deleted": true
}
```


# List API keys
Source: https://resend.com/docs/api-reference/api-keys/list-api-keys

GET /api-keys
Retrieve a list of API keys for the authenticated user.

## Query Parameters

If `limit` is not provided, all API keys will be returned
in a single response. Pass `limit` to paginate.
`after` and `before` only take effect together
with `limit`.

**limit** `number`

Number of API keys to retrieve.
<ul><li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more API keys (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more API keys (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.apiKeys.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->apiKeys->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"
resend.ApiKeys.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::ApiKeys.list
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")
	client.ApiKeys.List()
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _api_keys = resend.api_keys.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        resend.apiKeys().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ApiKeyListAsync();
Console.WriteLine( "Nr keys={0}", resp.Content.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/api-keys' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend api-keys list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "91f3200a-df72-4654-b0cd-f202395f5354",
      "name": "Production",
      "created_at": "2026-04-08 00:11:13.110779+00",
      "last_used_at": "2026-11-01 17:09:51.813959+00"
    }
  ]
}
```


# Update API key
Source: https://resend.com/docs/api-reference/api-keys/update-api-key

PATCH /api-keys/:api_key_id
Update the name of an existing API key.

> [!NOTE]
>
> This endpoint only updates the API key's name. To change an API key's
> [permission or domain](/docs/dashboard/api-keys/introduction#edit-api-key-details),
> edit the key in the [Resend Dashboard](https://resend.com/api-keys).

## Path Parameters

The API key ID.

## Body Parameters

**name** `string` *required*

The API key name. Maximum 50 characters.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.apiKeys.update(
  'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
  { name: 'Production' },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->apiKeys->update('b6d24b8e-af0b-4c3c-be0c-359bbd97381e', [
  'name' => 'Production'
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.ApiKeys.UpdateParams = {
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  "name": "Production",
}

resend.ApiKeys.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  id: "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  name: "Production"
}
Resend::ApiKeys.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")
	params := &resend.UpdateApiKeyRequest{
		Name: "Production",
	}
	client.ApiKeys.Update("b6d24b8e-af0b-4c3c-be0c-359bbd97381e", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::UpdateApiKeyOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _api_key = resend
    .api_keys
    .update(
      "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
      UpdateApiKeyOptions::new("Production"),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.apikeys.model.UpdateApiKeyOptions;
import com.resend.services.apikeys.model.UpdateApiKeyResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateApiKeyOptions params = UpdateApiKeyOptions
                .builder()
                .name("Production").build();

        UpdateApiKeyResponseSuccess apiKey = resend.apiKeys().update("b6d24b8e-af0b-4c3c-be0c-359bbd97381e", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ApiKeyUpdateAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ), "Production" );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/api-keys/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Production"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend api-keys update b6d24b8e-af0b-4c3c-be0c-359bbd97381e --name Production
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "api_key",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
}
```


# Create Automation
Source: https://resend.com/docs/api-reference/automations/create-automation

POST /automations
Create a new automation to automate email sequences.

## Body Parameters

**name** `string` *required*

The name of the automation.

**status** `string`

The status of the automation. Possible values are `enabled` or `disabled`.
Defaults to `disabled`.

**steps** `Step[]`

The steps that compose the automation graph. Must be provided together with
`connections`. See [Step
Properties](/docs/dashboard/automations/steps#step-properties) for full object
definition.

**connections** `Connection[]`

The connections between steps in the automation graph. Must be provided
together with `steps`. See [Connection
Properties](/docs/dashboard/automations/connections#connection-properties) for full
object definition.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.create({
  name: 'Welcome series',
  status: 'disabled',
  steps: [
    {
      key: 'start',
      type: 'trigger',
      config: { eventName: 'user.created' },
    },
    {
      key: 'welcome',
      type: 'send_email',
      config: {
        template: { id: '34a080c9-b17d-4187-ad80-5af20266e535' },
      },
    },
  ],
  connections: [{ from: 'start', to: 'welcome' }],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->create([
  'name' => 'Welcome series',
  'status' => 'disabled',
  'steps' => [
    [
      'key' => 'start',
      'type' => 'trigger',
      'config' => ['event_name' => 'user.created'],
    ],
    [
      'key' => 'welcome',
      'type' => 'send_email',
      'config' => [
        'template' => ['id' => '34a080c9-b17d-4187-ad80-5af20266e535'],
      ],
    ],
  ],
  'connections' => [['from' => 'start', 'to' => 'welcome']],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Automations.CreateParams = {
  "name": "Welcome series",
  "status": "disabled",
  "steps": [
    {
      "key": "start",
      "type": "trigger",
      "config": {"event_name": "user.created"},
    },
    {
      "key": "welcome",
      "type": "send_email",
      "config": {
        "template": {"id": "34a080c9-b17d-4187-ad80-5af20266e535"},
      },
    },
  ],
  "connections": [{"from": "start", "to": "welcome"}],
}

resend.Automations.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "Welcome series",
  status: "disabled",
  steps: [
    {
      key: "start",
      type: "trigger",
      config: { event_name: "user.created" },
    },
    {
      key: "welcome",
      type: "send_email",
      config: {
        template: { id: "34a080c9-b17d-4187-ad80-5af20266e535" },
      },
    },
  ],
  connections: [{ from: "start", to: "welcome" }],
}

Resend::Automations.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateAutomationRequest{
		Name:   "Welcome series",
		Status: resend.AutomationStatusDisabled,
		Steps: []resend.AutomationStep{
			{
				Key:  "start",
				Type: resend.AutomationStepTypeTrigger,
				Config: map[string]any{
					"event_name": "user.created",
				},
			},
			{
				Key:  "welcome",
				Type: resend.AutomationStepTypeSendEmail,
				Config: map[string]any{
					"template": map[string]any{
						"id": "34a080c9-b17d-4187-ad80-5af20266e535",
					},
				},
			},
		},
		Connections: []resend.AutomationConnection{
			{From: "start", To: "welcome"},
		},
	}

	client.Automations.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{
    AutomationStatus, AutomationTemplate, Connection, CreateAutomationOptions, SendEmailStepConfig,
    Step, TriggerStepConfig,
  },
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = CreateAutomationOptions {
    name: "Welcome series".to_owned(),
    status: AutomationStatus::Disabled,
    steps: vec![
      Step::Trigger {
        key: "start".to_owned(),
        config: TriggerStepConfig {
          event_name: "user.created".to_owned(),
        },
      },
      Step::SendEmail {
        key: "welcome".to_owned(),
        config: SendEmailStepConfig::new(AutomationTemplate::new(
          "34a080c9-b17d-4187-ad80-5af20266e535",
        )),
      },
    ],
    connections: vec![Connection::new("start", "welcome")],
  };
  let _automation = resend.automations.create(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.AutomationConnection;
import com.resend.services.automations.model.AutomationStatus;
import com.resend.services.automations.model.AutomationStep;
import com.resend.services.automations.model.CreateAutomationOptions;
import com.resend.services.automations.model.CreateAutomationResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateAutomationOptions options = CreateAutomationOptions.builder()
                .name("Welcome series")
                .status(AutomationStatus.DISABLED)
                .steps(
                    AutomationStep.trigger("start")
                        .eventName("user.created")
                        .build(),
                    AutomationStep.sendEmail("welcome")
                        .template("34a080c9-b17d-4187-ad80-5af20266e535")
                        .build()
                )
                .connections(
                    AutomationConnection.builder()
                        .from("start")
                        .to("welcome")
                        .build()
                )
                .build();

        CreateAutomationResponseSuccess response = resend.automations().create(options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.created" } );
var welcomeConfig = JsonSerializer.SerializeToElement( new { template = new { id = "34a080c9-b17d-4187-ad80-5af20266e535" } } );

var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
{
    Name = "Welcome series",
    Status = "disabled",
    Steps = new List<AutomationStepData>
    {
        new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
        new AutomationStepData { Ref = "welcome", Type = "send_email", Config = welcomeConfig },
    },
    Connections = new List<AutomationEdge>
    {
        new AutomationEdge { From = "start", To = "welcome" },
    },
} );
Console.WriteLine( "AutomationId={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/automations' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "name": "Welcome series",
  "steps": [
    {
      "key": "start",
      "type": "trigger",
      "config": { "event_name": "user.created" }
    },
    {
      "key": "welcome",
      "type": "send_email",
      "config": {
        "template": { "id": "34a080c9-b17d-4187-ad80-5af20266e535" }
      }
    }
  ],
  "connections": [
    { "from": "start", "to": "welcome" }
  ]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations create --name "Welcome series" --file ./automation.json
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "automation",
  "id": "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd"
}
```


# Delete Automation
Source: https://resend.com/docs/api-reference/automations/delete-automation

DELETE /automations/:automation_id
Remove an existing automation.

## Path Parameters

The automation ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.remove(
  'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->remove('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Automations.remove("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Automations.remove("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Automations.Remove("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _automation = resend
    .automations
    .delete("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.DeleteAutomationResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        DeleteAutomationResponseSuccess data = resend.automations().remove("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.AutomationDeleteAsync( new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ) );
Console.WriteLine( "Deleted={0}", resp.Content.Deleted );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations delete c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "automation",
  "id": "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
  "deleted": true
}
```


# Duplicate Automation
Source: https://resend.com/docs/api-reference/automations/duplicate-automation

POST /automations/:automation_id/duplicate
Duplicate an existing automation.

## Path Parameters

The automation ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.duplicate(
  'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->duplicate('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Automations.duplicate("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Automations.duplicate("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Automations.Duplicate("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _automation = resend
    .automations
    .duplicate("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.DuplicateAutomationResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        DuplicateAutomationResponseSuccess data = resend.automations().duplicate("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.AutomationDuplicateAsync( new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ) );
Console.WriteLine( "AutomationId={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/duplicate' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations duplicate c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "automation",
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3"
}
```


# Retrieve Automation
Source: https://resend.com/docs/api-reference/automations/get-automation

GET /automations/:automation_id
Retrieve a single automation.

## Path Parameters

The automation ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.get(
  'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->get('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Automations.get("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Automations.get("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Automations.Get("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _automation = resend
    .automations
    .get("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.Automation;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Automation data = resend.automations().get("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.AutomationRetrieveAsync( new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ) );
Console.WriteLine( "Name={0}", resp.Content.Name );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations get c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "automation",
  "id": "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
  "name": "Welcome series",
  "status": "disabled",
  "created_at": "2026-10-01 12:00:00.000000+00",
  "updated_at": "2026-10-01 12:00:00.000000+00",
  "steps": [
    {
      "key": "start",
      "type": "trigger",
      "config": { "event_name": "user.created" }
    },
    {
      "key": "welcome",
      "type": "send_email",
      "config": {
        "template": { "id": "34a080c9-b17d-4187-ad80-5af20266e535" }
      }
    }
  ],
  "connections": [
    {
      "from": "start",
      "to": "welcome",
      "type": "default"
    }
  ]
}
```


# Retrieve Automation Run
Source: https://resend.com/docs/api-reference/automations/get-automation-run

GET /automations/:automation_id/runs/:run_id
Retrieve a single automation run.

## Path Parameters

The automation ID.

The automation run ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.runs.get({
  automationId: 'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
  runId: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->runs->get(
  'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
  'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Automations.Runs.get(
  "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
  "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Automations::Runs.get(
  "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
  "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Automations.GetRun(
		"c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
		"a1b2c3d4-e5f6-7890-abcd-ef1234567890",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _automation = resend
    .automations
    .get_run(
      "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
      "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.AutomationRun;
import com.resend.services.automations.model.GetAutomationRunOptions;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        AutomationRun data = resend.automations().getRun(
                GetAutomationRunOptions.builder()
                        .automationId("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
                        .runId("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
                        .build()
        );
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.AutomationRunRetrieveAsync(
    new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ),
    new Guid( "a1b2c3d4-e5f6-7890-abcd-ef1234567890" )
);
Console.WriteLine( "Status={0}", resp.Content.Status );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/runs/a1b2c3d4-e5f6-7890-abcd-ef1234567890' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations runs get --automation-id c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd --run-id a1b2c3d4-e5f6-7890-abcd-ef1234567890
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "automation_run",
  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "status": "completed",
  "started_at": "2026-10-01 12:00:00.000000+00",
  "completed_at": "2026-10-01 12:05:00.000000+00",
  "created_at": "2026-10-01 12:00:00.000000+00",
  "steps": [
    {
      "key": "start",
      "type": "trigger",
      "status": "completed",
      "started_at": "2026-10-01 12:00:00.000000+00",
      "completed_at": "2026-10-01 12:00:01.000000+00",
      "output": null,
      "error": null,
      "created_at": "2026-10-01 12:00:00.000000+00"
    },
    {
      "key": "welcome",
      "type": "send_email",
      "status": "completed",
      "started_at": "2026-10-01 12:00:01.000000+00",
      "completed_at": "2026-10-01 12:00:02.000000+00",
      "output": null,
      "error": null,
      "created_at": "2026-10-01 12:00:01.000000+00"
    }
  ]
}
```


# List Automation Runs
Source: https://resend.com/docs/api-reference/automations/list-automation-runs

GET /automations/:automation_id/runs
Retrieve a list of automation runs.

## Path Parameters

The automation ID.

## Query Parameters

**limit** `number`

Number of automation-runs to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more automation-runs (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more automation-runs (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

Filter runs by status. Comma-separated list: `running`, `completed`, `failed`,
`cancelled`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.runs.list({
  automationId: 'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
  status: 'completed',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->runs->list('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Automations.Runs.list("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Automations::Runs.list("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Automations.ListRuns("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _automation = resend
    .automations
    .list_runs(
      "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
      None,
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.ListAutomationRunsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListAutomationRunsResponseSuccess data = resend.automations().listRuns("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.AutomationRunListAsync( new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ) );
Console.WriteLine( "Count={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/runs?status=completed' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations runs list c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "status": "completed",
      "started_at": "2026-10-01 12:00:00.000000+00",
      "completed_at": "2026-10-01 12:05:00.000000+00",
      "created_at": "2026-10-01 12:00:00.000000+00"
    },
    {
      "id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
      "status": "running",
      "started_at": "2026-10-02 08:30:00.000000+00",
      "completed_at": null,
      "created_at": "2026-10-02 08:30:00.000000+00"
    }
  ]
}
```


# List Automations
Source: https://resend.com/docs/api-reference/automations/list-automations

GET /automations
Retrieve a list of automations.

## Query Parameters

**limit** `number`

Number of automations to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more automations (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more automations (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

Filter automations by status. Possible values: `enabled`, `disabled`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Automations.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Automations.list
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Automations.List()
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _automations = resend.automations.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.ListAutomationsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListAutomationsResponseSuccess data = resend.automations().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.AutomationListAsync();
Console.WriteLine( "Count={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/automations' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
      "name": "Welcome series",
      "status": "enabled",
      "created_at": "2026-10-01 12:00:00.000000+00",
      "updated_at": "2026-10-01 12:00:00.000000+00"
    },
    {
      "id": "662892b2-4270-4130-a186-33a19752319d",
      "name": "Re-engagement",
      "status": "disabled",
      "created_at": "2026-09-15 08:30:00.000000+00",
      "updated_at": "2026-09-20 14:00:00.000000+00"
    }
  ]
}
```


# Stop Automation
Source: https://resend.com/docs/api-reference/automations/stop-automation

POST /automations/:automation_id/stop
Stop a running automation.

## Path Parameters

The automation ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.stop(
  'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->stop('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Automations.stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Automations.stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Automations.Stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _automation = resend
    .automations
    .stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.StopAutomationResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        StopAutomationResponseSuccess data = resend.automations().stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.AutomationStopAsync( new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ) );
Console.WriteLine( "Status={0}", resp.Content.Status );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/stop' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations stop c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "automation",
  "id": "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
  "status": "disabled"
}
```


# Update Automation
Source: https://resend.com/docs/api-reference/automations/update-automation

PATCH /automations/:automation_id
Update an existing automation.

> [!NOTE]
>
> Provide at least one of `name`, `status`, or both `steps` and `connections`.
> When updating the workflow graph, `steps` and `connections` must be sent
> together.

## Path Parameters

The automation ID.

## Body Parameters

**name** `string`

The name of the automation.

**status** `string`

The status of the automation. Possible values are `enabled` or `disabled`.

**steps** `Step[]`

The steps that compose the automation graph. Must be provided together with
`connections`. The graph of an `enabled` automation cannot be updated: disable
the automation first, or duplicate it and edit the copy. See [Step
Properties](/docs/dashboard/automations/steps#step-properties) for full object
definition.

**connections** `Connection[]`

The connections between steps in the automation graph. Must be provided
together with `steps`. See [Connection
Properties](/docs/dashboard/automations/connections#connection-properties) for full
object definition.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.update(
  'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
  { status: 'enabled' },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->update('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd', [
  'status' => 'enabled',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Automations.UpdateParams = {
  "automation_id": "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
  "status": "enabled",
}

resend.Automations.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  automation_id: "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
  status: "enabled",
}

Resend::Automations.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.UpdateAutomationRequest{
		Status: resend.AutomationStatusEnabled,
	}

	client.Automations.Update("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{AutomationStatus, UpdateAutomationOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = UpdateAutomationOptions::new().with_status(AutomationStatus::Enabled);
  let _automation = resend
    .automations
    .update("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd", opts)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.AutomationStatus;
import com.resend.services.automations.model.UpdateAutomationOptions;
import com.resend.services.automations.model.UpdateAutomationResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateAutomationOptions options = UpdateAutomationOptions.builder()
                .id("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
                .status(AutomationStatus.ENABLED)
                .build();

        UpdateAutomationResponseSuccess response = resend.automations().update(options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.AutomationUpdateAsync(
    new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ),
    new AutomationUpdateData { Status = "enabled" }
);
Console.WriteLine( "AutomationId={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "status": "enabled"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations update c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd --status enabled
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "automation",
  "id": "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd"
}
```


# Cancel Broadcast
Source: https://resend.com/docs/api-reference/broadcasts/cancel-broadcast

POST /broadcasts/:broadcast_id/cancel
Cancel a queued or scheduled broadcast.

You can only cancel Broadcasts that are `queued` or `scheduled`. When you cancel a Broadcast, here's what happens based on its status:

* `scheduled` → `draft`: no emails are sent. You can update the Broadcast and reschedule it to be sent.
* `queued` → `canceled`: emails that have already been sent are not affected, but any emails still in the queue will no longer be sent.

## Path Parameters

The broadcast ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.cancel(
  '559ac32e-9ef5-46fb-82a1-b76b840c0f7b',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->cancel('559ac32e-9ef5-46fb-82a1-b76b840c0f7b');
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Broadcasts.cancel(id="559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Broadcasts.cancel("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Broadcasts.Cancel("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _canceled = resend
    .broadcasts
    .cancel("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.CancelBroadcastResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

CancelBroadcastResponseSuccess data = resend.broadcasts().cancel("559ac32e-9ef5-46fb-82a1-b76b840c0f7b");
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.BroadcastCancelAsync( new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b/cancel' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts cancel 559ac32e-9ef5-46fb-82a1-b76b840c0f7b
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "broadcast",
  "id": "559ac32e-9ef5-46fb-82a1-b76b840c0f7b"
}
```


# Create Broadcast
Source: https://resend.com/docs/api-reference/broadcasts/create-broadcast

POST /broadcasts
Create a new broadcast to send to your contacts.

## Body Parameters

The ID of the segment you want to send to.

> [!NOTE]
>
> Audiences are now called Segments. Follow the [Migration
> Guide](/docs/dashboard/segments/migrating-from-audiences-to-segments).

**from** `string` *required*

Sender email address.

To include a friendly name, pass the sender as `Name <email@example.com>`, for example `Acme <onboarding@example.dev>`.

**subject** `string` *required*

Email subject.

Reply-to email address. For multiple addresses, send as an array of strings.

**html** `string`

The HTML version of the message. You can include Contact Properties in the
body of the Broadcast. Learn more about [Contact
Properties](/docs/dashboard/contacts/properties).

**text** `string`

The plain text version of the message. You can include Contact Properties in the body of the Broadcast. Learn more about [Contact Properties](/docs/dashboard/contacts/properties).

> [!NOTE]
>
> If not provided, the HTML will be used to generate a plain text version. You
> can opt out of this behavior by setting value to an empty string.

**react** `React.ReactNode`

The React component used to write the message. *Only available in the Node.js
SDK.*

**name** `string`

The friendly name of the broadcast. Only used for internal reference.

Optional. Omit it to send to every subscribed contact in the segment, without
checking topic preferences.

**send** `boolean`

Send the broadcast immediately after creation. Defaults to `false`.

> [!NOTE]
>
> When set to `true`, the broadcast will be sent or scheduled (if `scheduled_at` is provided) without requiring a separate call to the [Send Broadcast](/docs/api-reference/broadcasts/send-broadcast) endpoint.

Schedule the broadcast to be sent later. The date should be in natural language (e.g.: `in 1 min`) or ISO 8601 format (e.g: `2026-08-05T11:52:01.858Z`).

> [!WARNING]
>
> This parameter requires `send` to be set to `true`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

// Create a draft broadcast
const { data, error } = await resend.broadcasts.create({
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  from: 'Acme <onboarding@resend.dev>',
  subject: 'hello world',
  html: 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
});

// Create and send immediately
const { data: sent, error: sendError } = await resend.broadcasts.create({
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  from: 'Acme <onboarding@resend.dev>',
  subject: 'hello world',
  html: 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
  send: true,
});

// Create and schedule
const { data: scheduled, error: scheduleError } =
  await resend.broadcasts.create({
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
    from: 'Acme <onboarding@resend.dev>',
    subject: 'hello world',
    html: 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
    send: true,
    scheduledAt: 'in 1 hour',
  });
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Create a draft broadcast
$resend->broadcasts->create([
  'segment_id' => '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  'from' => 'Acme <onboarding@resend.dev>',
  'subject' => 'hello world',
  'html' => 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
]);

// Create and send immediately
$resend->broadcasts->create([
  'segment_id' => '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  'from' => 'Acme <onboarding@resend.dev>',
  'subject' => 'hello world',
  'html' => 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
  'send' => true,
]);

// Create and schedule
$resend->broadcasts->create([
  'segment_id' => '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  'from' => 'Acme <onboarding@resend.dev>',
  'subject' => 'hello world',
  'html' => 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
  'send' => true,
  'scheduled_at' => 'in 1 hour',
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Create a draft broadcast
params: resend.Broadcasts.CreateParams = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
}
resend.Broadcasts.create(params)

# Create and send immediately
params: resend.Broadcasts.CreateParams = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": True,
}
resend.Broadcasts.create(params)

# Create and schedule
params: resend.Broadcasts.CreateParams = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": True,
  "scheduled_at": "in 1 hour",
}
resend.Broadcasts.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Create a draft broadcast
params = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "hello world",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
}
Resend::Broadcasts.create(params)

# Create and send immediately
params = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": true,
}
Resend::Broadcasts.create(params)

# Create and schedule
params = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": true,
  "scheduled_at": "in 1 hour",
}
Resend::Broadcasts.create(params)

```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Create a draft broadcast
	params := &resend.CreateBroadcastRequest{
		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
		From:      "Acme <onboarding@resend.dev>",
		Html:      "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
		Subject:   "Hello, world!",
	}
	client.Broadcasts.Create(params)

	// Create and send immediately
	params = &resend.CreateBroadcastRequest{
		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
		From:      "Acme <onboarding@resend.dev>",
		Subject:   "Hello, world!",
		Html:      "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
		Send:      true,
	}
	client.Broadcasts.Create(params)

	// Create and schedule
	params = &resend.CreateBroadcastRequest{
		SegmentId:   "78261eea-8f8b-4381-83c6-79fa7120f1cf",
		From:        "Acme <onboarding@resend.dev>",
		Subject:     "Hello, world!",
		Html:        "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
		Send:        true,
		ScheduledAt: "in 1 hour",
	}
	client.Broadcasts.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateBroadcastOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let segment_id = "78261eea-8f8b-4381-83c6-79fa7120f1cf";
  let from = "Acme <onboarding@resend.dev>";
  let subject = "hello world";
  let html = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}";

  let opts = CreateBroadcastOptions::new(segment_id, from, subject).with_html(html);

  // Create a draft broadcast
  let _broadcast = resend.broadcasts.create(opts.clone()).await?;

  // Create and send immediately
  let _broadcast = resend
    .broadcasts
    .create(opts.clone().with_send(true))
    .await?;

  // Create and schedule
  let _broadcast = resend
    .broadcasts
    .create(opts.with_send(true).with_scheduled_at("in 1 hour"))
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.CreateBroadcastOptions;
import com.resend.services.broadcasts.model.CreateBroadcastResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

// Create a draft broadcast
CreateBroadcastOptions params = CreateBroadcastOptions.builder()
    .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
    .from("Acme <onboarding@resend.dev>")
    .subject("hello world")
    .html("Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
    .build();
CreateBroadcastResponseSuccess data = resend.broadcasts().create(params);

// Create and send immediately
CreateBroadcastOptions sendParams = CreateBroadcastOptions.builder()
    .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
    .from("Acme <onboarding@resend.dev>")
    .subject("hello world")
    .html("Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
    .send(true)
    .build();
CreateBroadcastResponseSuccess sent = resend.broadcasts().create(sendParams);

// Create and schedule
CreateBroadcastOptions scheduleParams = CreateBroadcastOptions.builder()
    .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
    .from("Acme <onboarding@resend.dev>")
    .subject("hello world")
    .html("Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
    .send(true)
    .scheduledAt("in 1 hour")
    .build();
CreateBroadcastResponseSuccess scheduled = resend.broadcasts().create(scheduleParams);
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// Create a draft broadcast
var resp = await resend.BroadcastAddAsync(
    new BroadcastData()
    {
        DisplayName = "Example Broadcast",
        SegmentId = new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ),
        From = "Acme <onboarding@resend.dev>",
        Subject = "Hello, world!",
        HtmlBody = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
    }
);

Console.WriteLine( "Broadcast Id={0}", resp.Content );

// Create and send immediately
var sent = await resend.BroadcastAddAsync(
    new BroadcastData()
    {
        DisplayName = "Example Broadcast",
        SegmentId = new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ),
        From = "Acme <onboarding@resend.dev>",
        Subject = "Hello, world!",
        HtmlBody = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
        SendAfterAdd = true,
    }
);

Console.WriteLine( "Broadcast Id={0}", sent.Content );

// Create and schedule
var scheduled = await resend.BroadcastAddAsync(
    new BroadcastData()
    {
        DisplayName = "Example Broadcast",
        SegmentId = new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ),
        From = "Acme <onboarding@resend.dev>",
        Subject = "Hello, world!",
        HtmlBody = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
        SendAfterAdd = true,
        MomentSchedule = DateTime.UtcNow.AddHours( 1 ),
    }
);

Console.WriteLine( "Broadcast Id={0}", scheduled.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Create a draft broadcast
curl -X POST 'https://api.resend.com/broadcasts' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'
{
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "hello world",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}"
}'

# Create and send immediately
curl -X POST 'https://api.resend.com/broadcasts' \
 -H 'Authorization: Bearer re_xxxxxxxxx' \
 -H 'Content-Type: application/json' \
 -d $'
{
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "hello world",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": true
}'

# Create and schedule
curl -X POST 'https://api.resend.com/broadcasts' \
 -H 'Authorization: Bearer re_xxxxxxxxx' \
 -H 'Content-Type: application/json' \
 -d $'
{
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "hello world",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": true,
  "scheduled_at": "in 1 hour"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Create a draft broadcast
resend broadcasts create \
  --from "Acme <onboarding@resend.dev>" \
  --subject "hello world" \
  --segment-id 78261eea-8f8b-4381-83c6-79fa7120f1cf \
  --html "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}"

# Create and send immediately
resend broadcasts create \
  --from "Acme <onboarding@resend.dev>" \
  --subject "hello world" \
  --segment-id 78261eea-8f8b-4381-83c6-79fa7120f1cf \
  --html "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}" \
  --send

# Create and schedule
resend broadcasts create \
  --from "Acme <onboarding@resend.dev>" \
  --subject "hello world" \
  --segment-id 78261eea-8f8b-4381-83c6-79fa7120f1cf \
  --html "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}" \
  --send \
  --scheduled-at "in 1 hour"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "broadcast",
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
}
```


# Delete Broadcast
Source: https://resend.com/docs/api-reference/broadcasts/delete-broadcast

DELETE /broadcasts/:broadcast_id
Remove an existing broadcast.

You can only delete Broadcasts that have not yet been sent (i.e., `draft` or `scheduled`). Deleting a `scheduled` Broadcast also cancels the scheduled delivery and the email will not be sent.

## Path Parameters

The broadcast ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.remove(
  '559ac32e-9ef5-46fb-82a1-b76b840c0f7b',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->remove('559ac32e-9ef5-46fb-82a1-b76b840c0f7b');
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Broadcasts.remove(id="559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Broadcasts.remove("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Broadcasts.Remove("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .broadcasts
    .delete("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.RemoveBroadcastResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

RemoveBroadcastResponseSuccess data = resend.broadcasts().remove("559ac32e-9ef5-46fb-82a1-b76b840c0f7b");
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.BroadcastDeleteAsync( new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts delete 559ac32e-9ef5-46fb-82a1-b76b840c0f7b
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "broadcast",
  "id": "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
  "deleted": true
}
```


# Duplicate Broadcast
Source: https://resend.com/docs/api-reference/broadcasts/duplicate-broadcast

POST /broadcasts/:broadcast_id/duplicate
Duplicate a broadcast.

Creates a new draft broadcast with the same segment, topic, sender, subject, reply-to, preview text, and content as the source. The copy is named after the source with ` (copy)` appended, truncated to 70 characters. Any broadcast can be duplicated, including sent ones.

## Path Parameters

The broadcast ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.duplicate(
  '559ac32e-9ef5-46fb-82a1-b76b840c0f7b',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->duplicate('559ac32e-9ef5-46fb-82a1-b76b840c0f7b');
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Broadcasts.duplicate(id="559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Broadcasts.duplicate("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Broadcasts.Duplicate("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _duplicated = resend
    .broadcasts
    .duplicate("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.DuplicateBroadcastResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

DuplicateBroadcastResponseSuccess data = resend.broadcasts().duplicate("559ac32e-9ef5-46fb-82a1-b76b840c0f7b");
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.BroadcastDuplicateAsync( new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b/duplicate' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts duplicate 559ac32e-9ef5-46fb-82a1-b76b840c0f7b
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "broadcast",
  "id": "1f85ae38-f5b9-4c1f-8766-667a53970fea"
}
```


# Retrieve Broadcast
Source: https://resend.com/docs/api-reference/broadcasts/get-broadcast

GET /broadcasts/:broadcast_id
Retrieve a single broadcast.

You can retrieve broadcasts created via both this API and the Resend dashboard.

## Path Parameters

The broadcast ID.

> [!NOTE]
>
> See all available `status` types in [the Broadcasts
> overview](/docs/dashboard/broadcasts/manage-broadcasts#understand-broadcast-statuses).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.get(
  '559ac32e-9ef5-46fb-82a1-b76b840c0f7b',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->get('559ac32e-9ef5-46fb-82a1-b76b840c0f7b');
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Broadcasts.get(id="559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Broadcasts.get("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Broadcasts.Get("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _broadcast = resend
    .broadcasts
    .get("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.GetBroadcastResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

GetBroadcastResponseSuccess data = resend.broadcasts().get("559ac32e-9ef5-46fb-82a1-b76b840c0f7b");
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.BroadcastRetrieveAsync( new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ) );
Console.WriteLine( "Broadcast name={0}", resp.Content.DisplayName );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts get 559ac32e-9ef5-46fb-82a1-b76b840c0f7b
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "broadcast",
  "id": "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
  "name": "Announcements",
  "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf", // now called segment_id
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "hello world",
  "reply_to": null,
  "preview_text": "Check out our latest announcements",
  "html": "<p>Hello {{{contact.first_name|there}}}!</p>",
  "text": "Hello {{{contact.first_name|there}}}!",
  "status": "draft",
  "created_at": "2026-12-01 19:32:22.980+00",
  "scheduled_at": null,
  "sent_at": null,
  "topic_id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
}
```


# List Clicked Links
Source: https://resend.com/docs/api-reference/broadcasts/list-broadcast-clicked-links

GET /broadcasts/:broadcast_id/clicked-links
Retrieve the links clicked in a broadcast.

Retrieve every link clicked in a broadcast, ranked by total clicks. Results are
paginated with cursors. See [Pagination](/docs/api-reference/pagination) for how
`after` and `before` work.

> [!NOTE]
>
> Responses are cached for up to 15 minutes, so requesting the same page again
> may return slightly stale data within that window.

## Path Parameters

The broadcast ID.

## Query Parameters

Number of links to return. Between `1` and `100`. Defaults to `20`.

Cursor to fetch the page after this link. Cannot be used with `before`.

Cursor to fetch the page before this link. Cannot be used with `after`.

## Response Fields

**object** `string`

Always `list`.

**has\_more** `boolean`

Whether more links exist beyond this page.

**data** `array`

The clicked links, ordered by total clicks, descending.

**properties**

**id** `string`

An opaque cursor for this row, used only for pagination. It does not
identify any entity in Resend.

**url** `string`

The URL that was clicked.

**clicks** `number`

Total clicks on this link, including repeat clicks by the same
recipient.

**unique\_clicks** `number`

The number of distinct recipients who clicked this link.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.clickedLinks(
  '559ac32e-9ef5-46fb-82a1-b76b840c0f7b',
  { limit: 20 },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->clickedLinks->list('559ac32e-9ef5-46fb-82a1-b76b840c0f7b',[
  'limit' => 20
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Broadcasts.clicked_links(
    id="559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
    params={"limit": 20},
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Broadcasts.clicked_links("559ac32e-9ef5-46fb-82a1-b76b840c0f7b", { limit: 20 })
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Broadcasts.ClickedLinks("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _links = resend
    .broadcasts
    .clicked_links("559ac32e-9ef5-46fb-82a1-b76b840c0f7b", ListOptions::default())
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.ListBroadcastClickedLinksResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

ListBroadcastClickedLinksResponseSuccess data = resend.broadcasts().clickedLinks("559ac32e-9ef5-46fb-82a1-b76b840c0f7b");
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.BroadcastClickedLinksAsync( new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ) );
Console.WriteLine( "Nr Links={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b/clicked-links?limit=20' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts clicked-links 559ac32e-9ef5-46fb-82a1-b76b840c0f7b --limit 20
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": true,
  "data": [
    {
      "id": "b2Zmc2V0OjA",
      "url": "https://resend.com/pricing",
      "clicks": 42,
      "unique_clicks": 30
    },
    {
      "id": "b2Zmc2V0OjE",
      "url": "https://resend.com/docs",
      "clicks": 17,
      "unique_clicks": 15
    }
  ]
}
```


# List Recipients
Source: https://resend.com/docs/api-reference/broadcasts/list-broadcast-recipients

GET /broadcasts/:broadcast_id/recipients
Retrieve the recipients of a broadcast for a given event type.

Retrieve the recipients of a broadcast, filtered by a single event `type` (for
example everyone who `opened`, `clicked`, or `bounced`). Results are paginated
with cursors. See [Pagination](/docs/api-reference/pagination) for how `after` and
`before` work.

> [!NOTE]
>
> Responses are cached for up to 15 minutes, so requesting the same page again
> may return slightly stale data within that window.

## Path Parameters

The broadcast ID.

## Query Parameters

The event to filter recipients by. One of `sent`, `delivered`, `opened`,
`clicked`, `bounced`, `complained`, `unsubscribed`, or `suppressed`.

Number of recipients to return. Between `1` and `100`. Defaults to `20`.

Cursor to fetch the page after this recipient. Cannot be used with `before`.

Cursor to fetch the page before this recipient. Cannot be used with `after`.

Filter recipients whose email contains this value.

Filter by bounce classification. One of `permanent`, `transient`, or
`undetermined`. Can only be used with `type=bounced`.

## Response Fields

**object** `string`

Always `list`.

**has\_more** `boolean`

Whether more recipients exist beyond this page.

**data** `array`

The recipients matching the requested `type`.

**properties**

**id** `string`

An opaque cursor for this row, used only for pagination. It does not
identify any entity in Resend. Use `contact_id` to reference the contact.

**contact\_id** `string | null`

The matching contact's ID. `null` when the recipient's email no longer
maps to a contact.

**email** `string`

The recipient's email address.

**count** `number`

How many times the recipient triggered the event. Only returned for
`type=opened` and `type=clicked`.

**bounce\_type** `string | null`

The bounce classification: `permanent`, `transient`, or `undetermined`.
Only returned for `type=bounced`.

**clicked\_links** `array`

The links this recipient clicked. Only returned for `type=clicked`.

**properties**

**url** `string`

The URL that was clicked.

**clicks** `number`

How many times the recipient clicked this link.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.recipients(
  '559ac32e-9ef5-46fb-82a1-b76b840c0f7b',
  { type: 'clicked', limit: 20 },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->recipients('559ac32e-9ef5-46fb-82a1-b76b840c0f7b', [
  'type' => 'clicked',
  'limit' => 20
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Broadcasts.recipients(
    "559ac32e-9ef5-46fb-82a1-b76b840c0f7b", {"type": "clicked", "limit": 20}
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Broadcasts.recipients(
  "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
  { type: "clicked", limit: 20 },
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	limit := 20
	client.Broadcasts.Recipients("559ac32e-9ef5-46fb-82a1-b76b840c0f7b", &resend.ListBroadcastRecipientsOptions{
		Type:  resend.BroadcastRecipientEventTypeClicked,
		Limit: &limit,
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::{BroadcastRecipientEventType, ListRecipientsOptions}, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let list_opts = ListRecipientsOptions::new(BroadcastRecipientEventType::Clicked).with_limit(20);

  let _recipients = resend
    .broadcasts
    .recipients("559ac32e-9ef5-46fb-82a1-b76b840c0f7b", list_opts)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.BroadcastRecipientEventType;
import com.resend.services.broadcasts.model.ListBroadcastRecipientsParams;
import com.resend.services.broadcasts.model.ListBroadcastRecipientsResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

ListBroadcastRecipientsResponseSuccess data = resend.broadcasts().recipients(
    "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
    ListBroadcastRecipientsParams.builder()
        .type(BroadcastRecipientEventType.CLICKED)
        .limit(20)
        .build());
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.BroadcastListRecipientsAsync(
    new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ),
    BroadcastRecipientEventType.Clicked,
    new BroadcastListRecipientsQuery() { Limit = 20 } );
Console.WriteLine( "Recipients={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b/recipients?type=clicked&limit=20' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts recipients 559ac32e-9ef5-46fb-82a1-b76b840c0f7b --type clicked --limit 20
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": true,
  "data": [
    {
      "id": "b2Zmc2V0OjA",
      "contact_id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "email": "carter@example.com",
      "count": 3,
      "clicked_links": [
        { "url": "https://resend.com/pricing", "clicks": 2 },
        { "url": "https://resend.com/docs", "clicks": 1 }
      ]
    },
    {
      "id": "b2Zmc2V0OjE",
      "contact_id": null,
      "email": "dana@example.com",
      "count": 1,
      "clicked_links": [{ "url": "https://resend.com/pricing", "clicks": 1 }]
    }
  ]
}
```


# List Broadcasts
Source: https://resend.com/docs/api-reference/broadcasts/list-broadcasts

GET /broadcasts
Retrieve a list of broadcast.

> [!NOTE]
>
> See all available `status` types in [the Broadcasts
> overview](/docs/dashboard/broadcasts/manage-broadcasts#understand-broadcast-statuses).

## Query Parameters

If `limit` is not provided, all broadcasts will be returned
in a single response. Pass `limit` to paginate.
`after` and `before` only take effect together
with `limit`.

**limit** `number`

Number of broadcasts to retrieve.
<ul><li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more broadcasts (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more broadcasts (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->list();
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Broadcasts.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Broadcasts.list()
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Broadcasts.List()
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _broadcasts = resend.broadcasts.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.ListBroadcastsResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

ListBroadcastsResponseSuccess data = resend.broadcasts().list();
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.BroadcastListAsync();
Console.WriteLine( "Nr Broadcasts={0}", resp.Content.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/broadcasts' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
      "name": "Announcements",
      "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf", // now called segment_id
      "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      "status": "draft",
      "created_at": "2026-11-01 15:13:31.723+00",
      "scheduled_at": null,
      "sent_at": null
    },
    {
      "id": "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
      "name": "Black Friday",
      "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf", // now called segment_id
      "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      "status": "sent",
      "created_at": "2026-12-01 19:32:22.980+00",
      "scheduled_at": "2026-12-02 19:32:22.980+00",
      "sent_at": "2026-12-02 19:32:22.980+00"
    }
  ]
}
```


# Send Broadcast
Source: https://resend.com/docs/api-reference/broadcasts/send-broadcast

POST /broadcasts/:broadcast_id/send
Start sending broadcasts to your audience through the Resend API.

> [!NOTE]
>
> You can send broadcasts only if they were created via the API.

## Path Parameters

The broadcast ID.

## Body Parameters

Schedule email to be sent later. The date should be in natural language (e.g.:
`in 1 min`) or ISO 8601 format (e.g: `2026-08-05T11:52:01.858Z`).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.send(
  '559ac32e-9ef5-46fb-82a1-b76b840c0f7b',
  {
    scheduledAt: 'in 1 min',
  },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->send('559ac32e-9ef5-46fb-82a1-b76b840c0f7b', [
  'scheduled_at' => 'in 1 min',
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Broadcasts.SendParams = {
  "broadcast_id": "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
  "scheduled_at": "in 1 min"
}
resend.Broadcasts.send(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  broadcast_id: "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
  scheduled_at: "in 1 min"
}
Resend::Broadcasts.send(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	sendParams := &resend.SendBroadcastRequest{
		BroadcastId: "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
		ScheduledAt: "in 1 min",
	}

	client.Broadcasts.Send(sendParams)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::SendBroadcastOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts =
    SendBroadcastOptions::new("559ac32e-9ef5-46fb-82a1-b76b840c0f7b").with_scheduled_at("in 1 min");

  let _broadcast = resend.broadcasts.send(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.SendBroadcastOptions;
import com.resend.services.broadcasts.model.SendBroadcastResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

SendBroadcastOptions params = SendBroadcastOptions.builder()
    .scheduledAt("in 1 min")
    .build();

SendBroadcastResponseSuccess data = resend.broadcasts().send(params,
    "498ee8e4-7aa2-4eb5-9f04-4194848049d1");
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// Send now
await resend.BroadcastSendAsync( new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ) );

// Send in 5 mins
await resend.BroadcastScheduleAsync(
    new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ),
    DateTime.UtcNow.AddMinutes( 5 ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b/send' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "scheduled_at": "in 1 min"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts send 559ac32e-9ef5-46fb-82a1-b76b840c0f7b --scheduled-at "in 1 min"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
}
```


# Update Broadcast
Source: https://resend.com/docs/api-reference/broadcasts/update-broadcast

PATCH /broadcasts/:broadcast_id
Update a broadcast to send to your contacts.

## Path Parameters

The ID of the broadcast you want to update.

## Body Parameters

The ID of the segment you want to send to.

> [!NOTE]
>
> Audiences are now called Segments. Follow the [Migration
> Guide](/docs/dashboard/segments/migrating-from-audiences-to-segments).

**from** `string`

Sender email address.

To include a friendly name, use the format `"Your Name <sender@domain.com>"`.

**subject** `string`

Email subject.

Reply-to email address. For multiple addresses, send as an array of strings.

**html** `string`

The HTML version of the message.

**text** `string`

The plain text version of the message.

> [!NOTE]
>
> If not provided, the HTML will be used to generate a plain text version. You
> can opt out of this behavior by setting value to an empty string.

**react** `React.ReactNode`

The React component used to write the message. *Only available in the Node.js
SDK.*

**name** `string`

The friendly name of the broadcast. Only used for internal reference.

The topic ID that the broadcast will be scoped to.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.update(
  '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794',
  {
    html: 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
  },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->update('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794', [
  'html' => 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Broadcasts.UpdateParams = {
  "broadcast_id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}"
}

resend.Broadcasts.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "broadcast_id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
}
Resend::Broadcasts.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.UpdateBroadcastRequest{
		BroadcastId: "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
		Html:        "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
	}

	client.Broadcasts.Update(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::UpdateBroadcastOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let id = "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794";
  let html = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}";

  let opts = UpdateBroadcastOptions::new().with_html(html);

  let _broadcast = resend.broadcasts.update(id, opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.broadcasts.model.UpdateBroadcastOptions;
import com.resend.services.broadcasts.model.UpdateBroadcastResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

UpdateBroadcastOptions params = UpdateBroadcastOptions.builder()
    .id("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
    .html("Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
    .build();

UpdateBroadcastResponseSuccess data = resend.broadcasts().update(params);
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.BroadcastUpdateAsync(
    new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ),
    new BroadcastUpdateData()
    {
        HtmlBody = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/broadcasts/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts update 49a3999c-0ce1-4ea6-ab68-afcd6dc2e794 \
  --html "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "broadcast",
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
}
```


# Create Contact Property
Source: https://resend.com/docs/api-reference/contact-properties/create-contact-property

POST /contact-properties
Create a custom property for your contacts.

## Body Parameters

The property key. Max length is `50` characters. Only alphanumeric characters
and underscores are allowed.

The property type. Possible values: `string` or `number`.

The default value to use when the property is not set for a contact. Must
match the type specified in the `type` field.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contactProperties.create({
  key: 'company_name',
  type: 'string',
  fallbackValue: 'Acme Corp',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contactProperties->create([
  'key' => 'company_name',
  'type' => 'string',
  'fallback_value' => 'Acme Corp',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

params: resend.ContactProperties.CreateParams = {
    "key": "company_name",
    "type": "string",
    "fallback_value": "Acme Corp",
}

contact_property = resend.ContactProperties.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

property = Resend::ContactProperties.create({
  key: "company_name",
  type: "string",
  fallback_value: "Acme Corp"
})
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateContactPropertyRequest{
		Key:           "company_name",
		Type:          "string",
		FallbackValue: "Acme Corp",
	}

	property, err := client.ContactProperties.CreateWithContext(ctx, params)
	if err != nil {
		panic(err)
	}
	fmt.Println(property)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateContactPropertyOptions, PropertyType},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let contact_property = CreateContactPropertyOptions::new("company_name", PropertyType::String)
    .with_fallback("Acme Corp");

  let _contact_property = resend.contacts.create_property(contact_property).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contactproperties.model.CreateContactPropertyOptions;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    CreateContactPropertyOptions options = CreateContactPropertyOptions.builder()
      .key("company_name")
      .type("string")
      .fallbackValue("Acme Corp")
      .build();

    resend.contactProperties().create(options);
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactPropCreateAsync( new ContactPropertyData() {
  Key = "company_name",
  PropertyType = ContactPropertyType.String,
  DefaultValue = "Acme Corp",
} );
Console.WriteLine( "Prop Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/contact-properties' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "key": "company_name",
  "type": "string",
  "fallback_value": "Acme Corp"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contact-properties create \
  --key company_name \
  --type string \
  --fallback-value "Acme Corp"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact_property",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
}
```


# Delete Contact Property
Source: https://resend.com/docs/api-reference/contact-properties/delete-contact-property

DELETE /contact-properties/:contact_property_id
Remove an existing contact property.

## Path Parameters

The Contact Property ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contactProperties.remove(
  'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contactProperties->remove('b6d24b8e-af0b-4c3c-be0c-359bbd97381');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

contact_property = resend.ContactProperties.remove('b6d24b8e-af0b-4c3c-be0c-359bbd97381e')
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::ContactProperties.remove("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	property, err := client.ContactProperties.RemoveWithContext(ctx, "b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
	if err != nil {
		panic(err)
	}
	fmt.Println(property)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .contacts
    .delete_property("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    resend.contactProperties().remove("b6d24b8e-af0b-4c3c-be0c-359bbd97381e");
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactPropDeleteAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/contact-properties/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contact-properties delete b6d24b8e-af0b-4c3c-be0c-359bbd97381e --yes
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact_property",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  "deleted": true
}
```


# Retrieve Contact Property
Source: https://resend.com/docs/api-reference/contact-properties/get-contact-property

GET /contact-properties/:contact_property_id
Retrieve a contact property by its ID.

## Path Parameters

The Contact Property ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contactProperties.get(
  'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contactProperties->get('b6d24b8e-af0b-4c3c-be0c-359bbd97381');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

contact_property = resend.ContactProperties.get('b6d24b8e-af0b-4c3c-be0c-359bbd97381e')
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

property = Resend::ContactProperties.get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	property, err := client.ContactProperties.GetWithContext(ctx, "b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
	if err != nil {
		panic(err)
	}
	fmt.Println(property)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _property = resend
    .contacts
    .get_property("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    resend.contactProperties().get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e");
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactPropRetrieveAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
Console.WriteLine( "Prop Id={0}", resp.Content.Id );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/contact-properties/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contact-properties get b6d24b8e-af0b-4c3c-be0c-359bbd97381e
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact_property",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  "key": "company_name",
  "type": "string",
  "fallback_value": "Acme Corp",
  "created_at": "2026-04-08 00:11:13.110779+00"
}
```


# List Contact Properties
Source: https://resend.com/docs/api-reference/contact-properties/list-contact-properties

GET /contact-properties
Retrieve a list of contact properties.

## Query Parameters

**limit** `number`

Number of contact-properties to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more contact-properties (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more contact-properties (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contactProperties.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contactProperties->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

contact_properties = resend.ContactProperties.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

properties = Resend::ContactProperties.list
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	properties, err := client.ContactProperties.ListWithContext(ctx)
	if err != nil {
		panic(err)
	}
	fmt.Println(properties)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _contact_properties = resend
    .contacts
    .list_properties(ListOptions::default())
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    resend.contactProperties().list();
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactPropListAsync();
Console.WriteLine( "Nr Props={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/contact-properties' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contact-properties list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
      "key": "company_name",
      "type": "string",
      "fallback_value": "Acme Corp",
      "created_at": "2026-04-08 00:11:13.110779+00"
    }
  ]
}
```


# Update Contact Property
Source: https://resend.com/docs/api-reference/contact-properties/update-contact-property

PATCH /contact-properties/:contact_property_id
Update an existing contact property.

## Path Parameters

The Contact Property ID.

> [!NOTE]
>
> The `key` and `type` fields cannot be changed after creation. This preserves
> data integrity for existing contact values.

## Body Parameters

The default value to use when the property is not set for a contact. Must
match the type of the property.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contactProperties.update({
  id: 'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
  fallbackValue: 'Example Company',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contactProperties->update('b6d24b8e-af0b-4c3c-be0c-359bbd97381', [
  'fallback_value' => 'Example Company',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

params: resend.ContactProperties.UpdateParams = {
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    "fallback_value": "Example Company",
}

contact_property = resend.ContactProperties.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

property = Resend::ContactProperties.update({
  id: "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  fallback_value: "Example Company"
})
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.UpdateContactPropertyRequest{
		Id:            "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
		FallbackValue: "Example Company",
	}

	property, err := client.ContactProperties.UpdateWithContext(ctx, params)
	if err != nil {
		panic(err)
	}
	fmt.Println(property)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::ContactPropertyChanges, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let update = ContactPropertyChanges::default().with_fallback("Example Company");
  let _contact_property = resend
    .contacts
    .update_property("b6d24b8e-af0b-4c3c-be0c-359bbd97381e", update)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contactproperties.model.UpdateContactPropertyOptions;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    UpdateContactPropertyOptions options = UpdateContactPropertyOptions.builder()
      .id("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
      .fallbackValue("Example Company")
      .build();

    resend.contactProperties().update(options);
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactPropUpdateAsync(
  new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ),
  new ContactPropertyUpdateData() {
    DefaultValue = "Example Company",
  }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/contact-properties/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "fallback_value": "Example Company"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contact-properties update b6d24b8e-af0b-4c3c-be0c-359bbd97381e \
  --fallback-value "Example Company"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact_property",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
}
```


# Add Contact to Segment
Source: https://resend.com/docs/api-reference/contacts/add-contact-to-segment

POST /contacts/:contact_id/segments/:segment_id
Add an existing contact to a segment.

## Path Parameters

Either `id` or `email` must be provided.

**id** `string`

The Contact ID.

**email** `string`

The Contact Email.

The Segment ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.segments.add({
  contactId: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  // or: email: 'steve.wozniak@gmail.com',
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Add by contact id
$resend->contacts->segments->add(
  contact: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
);

// Add by contact email
$resend->contacts->segments->add(
  contact: 'steve.wozniak@gmail.com',
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

# Add by contact id
params: resend.Contacts.Segments.AddParams = {
    "segment_id": '78261eea-8f8b-4381-83c6-79fa7120f1cf',
    "contact_id": 'e169aa45-1ecf-4183-9955-b1499d5701d3',
}

response = resend.Contacts.Segments.add(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

# Add by contact id
result = Resend::Contacts::Segments.add(
  contact_id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  segment_id: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
)

# Add by contact email
result = Resend::Contacts::Segments.add(
  email: 'steve.wozniak@gmail.com',
  segment_id: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	// Add by contact id
	addParams := &resend.AddContactSegmentRequest{
		ContactId: "e169aa45-1ecf-4183-9955-b1499d5701d3",
		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
	}

	response, err := client.Contacts.Segments.AddWithContext(ctx, addParams)
	if err != nil {
		panic(err)
	}
	fmt.Println(response)

	// Add by contact email
	addByEmailParams := &resend.AddContactSegmentRequest{
		Email:     "steve.wozniak@gmail.com",
		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
	}

	response, err = client.Contacts.Segments.AddWithContext(ctx, addByEmailParams)
	if err != nil {
		panic(err)
	}
	fmt.Println(response)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  // Update by contact id
  let _contact = resend
    .contacts
    .add_contact_segment(
      "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    )
    .await?;

  // // Update by contact email
  let _contact = resend
    .contacts
    .add_contact_segment(
      "steve.wozniak@gmail.com",
      "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.AddContactToSegmentOptions;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    // Add by contact id
    AddContactToSegmentOptions optionsById = AddContactToSegmentOptions.builder()
      .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
      .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
      .build();

    resend.contacts().segments().add(optionsById);

    // Add by contact email
    AddContactToSegmentOptions optionsByEmail = AddContactToSegmentOptions.builder()
      .email("steve.wozniak@gmail.com")
      .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
      .build();

    resend.contacts().segments().add(optionsByEmail);
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.ContactAddToSegmentAsync(
    contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
    segmentId: new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
// Update by contact id
curl -X POST 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
     -H 'Authorization: Bearer re_xxxxxxxxx'

// Update by contact email
curl -X POST 'https://api.resend.com/contacts/steve.wozniak@gmail.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Add by contact id
resend contacts add-segment e169aa45-1ecf-4183-9955-b1499d5701d3 \
  --segment-id 78261eea-8f8b-4381-83c6-79fa7120f1cf

# Add by contact email
resend contacts add-segment steve.wozniak@gmail.com \
  --segment-id 78261eea-8f8b-4381-83c6-79fa7120f1cf
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf"
}
```


# Create Contact
Source: https://resend.com/docs/api-reference/contacts/create-contact

POST /contacts
Create a contact.

## Body Parameters

**email** `string` *required*

The email address of the contact.

The first name of the contact.

The last name of the contact.

**unsubscribed** `boolean`

The Contact's global subscription status. If set to `true`, the contact will
be unsubscribed from all Broadcasts.

**properties** `object`

A map of custom property keys and values to create.

**custom properties**

**key** `string` *required*

The property key.

**value** `string` *required*

The property value.

**segments** `array`

Array of objects. Each object must contain the ID of the segment that you'd like to add the contact to.

**segments**

**id** `string` *required*

The segment ID.

**topics** `array`

Array of topic subscriptions for the contact.

**topics**

**id** `string` *required*

The topic ID.

**subscription** `'opt_in' | 'opt_out'` *required*

The subscription status for this topic.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.create({
  email: 'steve.wozniak@gmail.com',
  firstName: 'Steve',
  lastName: 'Wozniak',
  unsubscribed: false,
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contacts->create(
  parameters: [
    'email' => 'steve.wozniak@gmail.com',
    'first_name' => 'Steve',
    'last_name' => 'Wozniak',
    'unsubscribed' => false
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Contacts.CreateParams = {
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak",
  "unsubscribed": False,
}

resend.Contacts.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak",
  "unsubscribed": false,
}

Resend::Contacts.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateContactRequest{
		Email:        "steve.wozniak@gmail.com",
		FirstName:    "Steve",
		LastName:     "Wozniak",
		Unsubscribed: false,
	}

	client.Contacts.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateContactOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let contact = CreateContactOptions::new("steve.wozniak@gmail.com")
    .with_first_name("Steve")
    .with_last_name("Wozniak")
    .with_unsubscribed(false);

  let _contact = resend.contacts.create(contact).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.CreateContactOptions;
import com.resend.services.contacts.model.CreateContactResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateContactOptions params = CreateContactOptions.builder()
                .email("steve.wozniak@gmail.com")
                .firstName("Steve")
                .lastName("Wozniak")
                .unsubscribed(false)
                .build();

        CreateContactResponseSuccess data = resend.contacts().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactAddAsync(
    new ContactData()
    {
        Email = "steve.wozniak@gmail.com",
        FirstName = "Steve",
        LastName = "Wozniak",
        IsUnsubscribed = false,
    }
);
Console.WriteLine( "Contact Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/contacts' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak",
  "unsubscribed": false
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts create \
  --email steve.wozniak@gmail.com \
  --first-name Steve \
  --last-name Wozniak
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact",
  "id": "479e3145-dd38-476b-932c-529ceb705947"
}
```


# Create Contact Import
Source: https://resend.com/docs/api-reference/contacts/create-contact-import

POST /contacts/imports
Create a contact import.

## Body Parameters

This endpoint accepts `multipart/form-data`. Object and array fields
(`column_map`, `segments`, `topics`) must be sent as JSON-encoded strings.

**file** `file` *required*

The CSV file to import. The file must be sent as a form field named `file`.
Maximum file size is 200MB.

**column\_map** `object`

Maps CSV columns to contact fields.

**column\_map**

**email** `string`

The CSV column that contains contact email addresses.

**first\_name** `string`

The CSV column that contains contact first names.

**last\_name** `string`

The CSV column that contains contact last names.

**unsubscribed** `string`

The CSV column that contains the contact's global subscription status.

**properties** `object`

A map of custom property keys to CSV columns.

**properties**

**key** `object`

The custom property key.

**property mapping**

**column** `string` *required*

The CSV column that contains the custom property value.

**type** `'string' | 'number' | 'boolean'`

The custom property value type. Defaults to `string`.

**on\_conflict** `'upsert' | 'skip'`

How to handle contacts that already exist. Defaults to `upsert`.

**segments** `array`

Array of objects. Each object must contain the ID of the segment that you'd
like to add the imported contacts to.

**segments**

**id** `string` *required*

The segment UUID.

**topics** `array`

Array of topic subscriptions for imported contacts.

**topics**

**id** `string` *required*

The Topic UUID.

**subscription** `'opt_in' | 'opt_out'` *required*

The subscription status for this topic.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { readFile } from 'node:fs/promises';
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const file = new Blob([await readFile('contacts.csv')], {
  type: 'text/csv',
});

const { data, error } = await resend.contacts.imports.create({
  file,
  columnMap: {
    email: 'Email',
    firstName: 'First Name',
    lastName: 'Last Name',
    properties: {
      plan: {
        column: 'Plan',
        type: 'string',
      },
    },
  },
  onConflict: 'upsert',
  segments: [{ id: '78e7a5c6-9a91-4c63-9d1f-3b9c0b5b9ab6' }],
  topics: [
    {
      id: '059ac693-2fc8-4c13-8b27-01350d638a17',
      subscription: 'opt_in',
    },
  ],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$file = fopen('contacts.csv', 'r');

$resend->contacts->imports->create([
  'file' => $file,
  'column_map' => [
    'email' => 'Email',
    'first_name' => 'First Name',
    'last_name' => 'Last Name',
    'properties' => [
      'plan' => [
        'column' => 'Plan',
        'type' => 'string',
      ],
    ],
  ],
  'on_conflict' => 'upsert',
  'segments' => [['id' => '78e7a5c6-9a91-4c63-9d1f-3b9c0b5b9ab6']],
  'topics' => [
    [
      'id' => '059ac693-2fc8-4c13-8b27-01350d638a17',
      'subscription' => 'opt_in',
    ],
  ],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

with open("contacts.csv", "rb") as f:
    file_content = f.read()

params: resend.Contacts.Imports.CreateParams = {
    "file": file_content,
    "column_map": {
        "email": "Email",
        "first_name": "First Name",
        "last_name": "Last Name",
        "properties": {
            "plan": {
                "column": "Plan",
                "type": "string",
            },
        },
    },
    "on_conflict": "upsert",
    "segments": [{"id": "78e7a5c6-9a91-4c63-9d1f-3b9c0b5b9ab6"}],
    "topics": [
        {
            "id": "059ac693-2fc8-4c13-8b27-01350d638a17",
            "subscription": "opt_in",
        },
    ],
}

resend.Contacts.Imports.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  file: File.read("contacts.csv"),
  column_map: {
    "email" => "Email",
    "first_name" => "First Name",
    "last_name" => "Last Name",
    "properties" => {
      "plan" => {
        "column" => "Plan",
        "type" => "string"
      }
    }
  },
  on_conflict: "upsert",
  segments: [{ id: "78e7a5c6-9a91-4c63-9d1f-3b9c0b5b9ab6" }],
  topics: [
    { id: "059ac693-2fc8-4c13-8b27-01350d638a17", subscription: "opt_in" }
  ]
}

Resend::Contacts::Imports.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"os"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	file, err := os.ReadFile("contacts.csv")
	if err != nil {
		panic(err)
	}

	params := &resend.CreateContactImportRequest{
		File:       file,
		Filename:   "contacts.csv",
		OnConflict: "upsert",
		ColumnMap: map[string]any{
			"email":      "Email",
			"first_name": "First Name",
			"last_name":  "Last Name",
			"properties": map[string]any{
				"plan": map[string]any{
					"column": "Plan",
					"type":   "string",
				},
			},
		},
		Segments: []resend.ContactImportSegment{{Id: "78e7a5c6-9a91-4c63-9d1f-3b9c0b5b9ab6"}},
		Topics: []resend.TopicSubscriptionUpdate{
			{Id: "059ac693-2fc8-4c13-8b27-01350d638a17", Subscription: "opt_in"},
		},
	}

	client.Contacts.Imports.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use std::fs::File;

use resend_rs::{
  Resend, Result,
  types::{
    ContactImportColumnMap, ContactImportOnConflict, ContactImportPropertyMapping,
    ContactImportPropertyType, ContactImportTopic, ContactImportTopicSubscription,
    CreateContactImportOptions,
  },
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let file = File::open("contacts.csv").unwrap();

  let contact_import = CreateContactImportOptions::new()
    .with_column_map(
      ContactImportColumnMap::new()
        .with_email("Email")
        .with_first_name("First Name")
        .with_last_name("Last Name")
        .with_property(
          "plan",
          ContactImportPropertyMapping {
            column: "Plan".to_owned(),
            r#type: ContactImportPropertyType::String,
          },
        ),
    )
    .with_on_conflict(ContactImportOnConflict::Upsert)
    .with_segment("78e7a5c6-9a91-4c63-9d1f-3b9c0b5b9ab6")
    .with_topic(ContactImportTopic {
      id: "059ac693-2fc8-4c13-8b27-01350d638a17".to_owned(),
      subscription: ContactImportTopicSubscription::OptIn,
    });

  let _data = resend.contacts.create_import(file, contact_import).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.contacts.model.*;
import java.io.File;

public class Main {
    public static void main(String[] args) throws Exception {
        Resend resend = new Resend("re_xxxxxxxxx");

        ContactImportColumnMap columnMap = ContactImportColumnMap.builder()
                .email("Email")
                .firstName("First Name")
                .lastName("Last Name")
                .property("plan", ContactImportPropertyMapping.builder()
                        .column("Plan")
                        .type("string")
                        .build())
                .build();

        CreateContactImportOptions params = CreateContactImportOptions.builder()
                .file(new File("contacts.csv"))
                .columnMap(columnMap)
                .onConflict("upsert")
                .segments(new ContactImportSegmentReference("78e7a5c6-9a91-4c63-9d1f-3b9c0b5b9ab6"))
                .topics(ContactImportTopicSubscription.builder()
                        .id("059ac693-2fc8-4c13-8b27-01350d638a17")
                        .subscription("opt_in")
                        .build())
                .build();

        CreateContactImportResponseSuccess data = resend.contacts().imports().create(params);
    }
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/contacts/imports' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -F 'file=@contacts.csv;type=text/csv' \
     -F 'column_map={"email":"Email","first_name":"First Name","last_name":"Last Name","properties":{"plan":{"column":"Plan","type":"string"}}}' \
     -F 'on_conflict=upsert' \
     -F 'segments=[{"id":"78e7a5c6-9a91-4c63-9d1f-3b9c0b5b9ab6"}]' \
     -F 'topics=[{"id":"059ac693-2fc8-4c13-8b27-01350d638a17","subscription":"opt_in"}]'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts imports create \
  --file contacts.csv \
  --column-map '{"email":"Email","firstName":"First Name","lastName":"Last Name","properties":{"plan":{"column":"Plan","type":"string"}}}' \
  --on-conflict upsert \
  --segment-id 78e7a5c6-9a91-4c63-9d1f-3b9c0b5b9ab6 \
  --topics '[{"id":"059ac693-2fc8-4c13-8b27-01350d638a17","subscription":"opt_in"}]'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact_import",
  "id": "479e3145-dd38-476b-932c-529ceb705947"
}
```


# Delete Contact
Source: https://resend.com/docs/api-reference/contacts/delete-contact

DELETE /contacts/:contact_id
Remove an existing contact.

## Path Parameters

Either `id` or `email` must be provided.

**id** `string`

The Contact ID.

**email** `string`

The Contact email.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.remove({
  id: '520784e2-887d-4c25-b53c-4ad46ad38100',
  // or: email: 'acme@example.com',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Delete by contact id
$resend->contacts->remove(
  idOrEmail: '520784e2-887d-4c25-b53c-4ad46ad38100'
);

// Delete by contact email
$resend->contacts->remove(
  idOrEmail: 'acme@example.com'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Delete by contact id
resend.Contacts.remove(
  id="520784e2-887d-4c25-b53c-4ad46ad38100"
)

# Delete by contact email
resend.Contacts.remove(
  email="acme@example.com"
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Delete by contact id
Resend::Contacts.remove(
  id: "520784e2-887d-4c25-b53c-4ad46ad38100"
)

# Delete by contact email
Resend::Contacts.remove(
  email: "acme@example.com"
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Delete by contact id
	client.Contacts.Remove(&resend.RemoveContactOptions{
		Id: "520784e2-887d-4c25-b53c-4ad46ad38100",
	})

	// Delete by contact email
	client.Contacts.Remove(&resend.RemoveContactOptions{
		Id: "acme@example.com",
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  // Delete by contact id
  let _deleted = resend
    .contacts
    .delete("520784e2-887d-4c25-b53c-4ad46ad38100")
    .await?;

  // Delete by contact email
  let _deleted = resend
    .contacts
    .delete("acme@example.com")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.RemoveContactOptions;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        // Delete by contact id
        resend.contacts().remove(RemoveContactOptions.builder()
                        .id("520784e2-887d-4c25-b53c-4ad46ad38100")
                        .build());

        // Delete by contact email
        resend.contacts().remove(RemoveContactOptions.builder()
                        .email("acme@example.com")
                        .build());
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// By Id
await resend.ContactDeleteAsync(
    contactId: new Guid( "520784e2-887d-4c25-b53c-4ad46ad38100" )
);

// By Email
await resend.ContactDeleteByEmailAsync(
    "acme@example.com"
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Delete by contact id
curl -X DELETE 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
     -H 'Authorization: Bearer re_xxxxxxxxx'

# Deleted by contact email
curl -X DELETE 'https://api.resend.com/contacts/acme@example.com' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Delete by contact id
resend contacts delete 520784e2-887d-4c25-b53c-4ad46ad38100

# Delete by contact email
resend contacts delete acme@example.com
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact",
  "contact": "520784e2-887d-4c25-b53c-4ad46ad38100",
  "deleted": true
}
```


# Delete Contact Segment
Source: https://resend.com/docs/api-reference/contacts/delete-contact-segment

DELETE /contacts/:contact_id/segments/:segment_id
Remove an existing contact from a segment.

## Path Parameters

Either `id` or `email` must be provided.

**id** `string`

The Contact ID.

**email** `string`

The Contact Email.

The Segment ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.segments.remove({
  contactId: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  // or: email: 'steve.wozniak@gmail.com',
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Remove by contact id
$resend->contacts->segments->remove(
  contact: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
);

// Remove by contact email
$resend->contacts->segments->remove(
  contact: 'steve.wozniak@gmail.com',
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

# Remove by contact id
params: resend.Contacts.Segments.RemoveParams = {
    "segment_id": '78261eea-8f8b-4381-83c6-79fa7120f1cf',
    "contact_id": 'e169aa45-1ecf-4183-9955-b1499d5701d3',
}

response = resend.Contacts.Segments.remove(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

# Remove by contact id
removed = Resend::Contacts::Segments.remove(
  contact_id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  segment_id: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
)

# Remove by contact email
removed = Resend::Contacts::Segments.remove(
  email: 'steve.wozniak@gmail.com',
  segment_id: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	// Remove by contact id
	removeParams := &resend.RemoveContactSegmentRequest{
		ContactId: "e169aa45-1ecf-4183-9955-b1499d5701d3",
		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
	}

	response, err := client.Contacts.Segments.RemoveWithContext(ctx, removeParams)
	if err != nil {
		panic(err)
	}
	fmt.Println(response)

	// Remove by contact email
	removeByEmailParams := &resend.RemoveContactSegmentRequest{
		Email:     "steve.wozniak@gmail.com",
		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
	}

	response, err = client.Contacts.Segments.RemoveWithContext(ctx, removeByEmailParams)
	if err != nil {
		panic(err)
	}
	fmt.Println(response)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  // Remove by contact id
  let _contact = resend
    .contacts
    .delete_contact_segment(
      "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    )
    .await?;

  // Remove by contact email
  let _contact = resend
    .contacts
    .delete_contact_segment(
      "steve.wozniak@gmail.com",
      "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.RemoveContactFromSegmentOptions;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    // Remove by contact id
    RemoveContactFromSegmentOptions optionsById = RemoveContactFromSegmentOptions.builder()
      .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
      .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
      .build();

    resend.contacts().segments().remove(optionsById);

    // Remove by contact email
    RemoveContactFromSegmentOptions optionsByEmail = RemoveContactFromSegmentOptions.builder()
      .email("steve.wozniak@gmail.com")
      .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
      .build();

    resend.contacts().segments().remove(optionsByEmail);
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.ContactRemoveFromSegmentAsync(
    contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
    segmentId: new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Remove by contact id
curl -X DELETE 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
     -H 'Authorization: Bearer re_xxxxxxxxx'

# Remove by contact email
curl -X DELETE 'https://api.resend.com/contacts/steve.wozniak@gmail.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Remove by contact id
resend contacts remove-segment e169aa45-1ecf-4183-9955-b1499d5701d3 78261eea-8f8b-4381-83c6-79fa7120f1cf

# Remove by contact email
resend contacts remove-segment steve.wozniak@gmail.com 78261eea-8f8b-4381-83c6-79fa7120f1cf
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact_segment",
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "audienceId": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "deleted": true
}
```


# Retrieve Contact
Source: https://resend.com/docs/api-reference/contacts/get-contact

GET /contacts/:contact_id
Retrieve a single contact.

## Path Parameters

Either `id` or `email` must be provided.

**id** `string`

The Contact ID.

**email** `string`

The Contact Email.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.get({
  id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  // or: email: 'steve.wozniak@gmail.com',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Get by contact id
$resend->contacts->get(
  idOrEmail: 'e169aa45-1ecf-4183-9955-b1499d5701d3'
);

// Get by contact email
$resend->contacts->get(
  idOrEmail: 'steve.wozniak@gmail.com'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Get by contact id
resend.Contacts.get(
  id="e169aa45-1ecf-4183-9955-b1499d5701d3",
)

# Get by contact email
resend.Contacts.get(
  email="steve.wozniak@gmail.com",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Get by contact id
params = {
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
}

Resend::Contacts.get(params)

# Get by contact email
params = {
  "email": "steve.wozniak@gmail.com",
}

Resend::Contacts.get(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Get by contact id
	client.Contacts.Get(&resend.GetContactOptions{
		Id: "e169aa45-1ecf-4183-9955-b1499d5701d3",
	})

	// Get by contact email
	client.Contacts.Get(&resend.GetContactOptions{
		Id: "steve.wozniak@gmail.com",
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  // Get by contact id
  let _contact = resend
    .contacts
    .get("e169aa45-1ecf-4183-9955-b1499d5701d3")
    .await?;

  // Get by contact email
  let _contact = resend
    .contacts
    .get("steve.wozniak@gmail.com")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.GetContactOptions;
import com.resend.services.contacts.model.GetContactResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetContactOptions params = GetContactOptions.builder()
                .id("e169aa45-1ecf-4183-9955-b1499d5701d3") // or: .email("steve.wozniak@gmail.com")
                .build();

        GetContactResponseSuccess data = resend.contacts().get(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// Get by contact id
var resp1 = await resend.ContactRetrieveAsync(
    contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" )
);

// Get by contact email
var resp2 = await resend.ContactRetrieveByEmailAsync(
    email: "steve.wozniak@gmail.com"
);

Console.WriteLine( "Contact Email={0}", resp2.Content.Email );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Get by contact id
curl -X GET 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3' \
     -H 'Authorization: Bearer re_xxxxxxxxx'

# Get by contact email
curl -X GET 'https://api.resend.com/contacts/steve.wozniak@gmail.com' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Get by contact id
resend contacts get e169aa45-1ecf-4183-9955-b1499d5701d3

# Get by contact email
resend contacts get steve.wozniak@gmail.com
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact",
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak",
  "created_at": "2026-10-06 23:47:56.678+00",
  "unsubscribed": false,
  "properties": {
    "company_name": {
      "value": "Acme Corp",
      "type": "string"
    },
    "department": {
      "value": "Engineering",
      "type": "string"
    }
  }
}
```


# Retrieve Contact Import
Source: https://resend.com/docs/api-reference/contacts/get-contact-import

GET /contacts/imports/:id
Retrieve a single contact import.

## Path Parameters

**id** `string` *required*

The Contact Import ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.imports.get(
  '479e3145-dd38-476b-932c-529ceb705947',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contacts->imports->get('479e3145-dd38-476b-932c-529ceb705947');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Contacts.Imports.get("479e3145-dd38-476b-932c-529ceb705947")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Contacts::Imports.get("479e3145-dd38-476b-932c-529ceb705947")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Contacts.Imports.Get("479e3145-dd38-476b-932c-529ceb705947")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _data = resend
    .contacts
    .get_import("479e3145-dd38-476b-932c-529ceb705947")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.contacts.model.GetContactImportResponseSuccess;

public class Main {
    public static void main(String[] args) throws Exception {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetContactImportResponseSuccess data = resend
                .contacts()
                .imports()
                .get("479e3145-dd38-476b-932c-529ceb705947");
    }
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/contacts/imports/479e3145-dd38-476b-932c-529ceb705947' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts imports get 479e3145-dd38-476b-932c-529ceb705947
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact_import",
  "id": "479e3145-dd38-476b-932c-529ceb705947",
  "status": "completed",
  "created_at": "2026-05-15 18:32:37.823+00",
  "completed_at": "2026-05-15 18:33:42.916+00",
  "counts": {
    "total": 1200,
    "created": 800,
    "updated": 300,
    "skipped": 75,
    "failed": 25
  }
}
```


# Retrieve Contact Topics
Source: https://resend.com/docs/api-reference/contacts/get-contact-topics

GET /contacts/:contact_id/topics
Retrieve a list of topics subscriptions for a contact.

## Path Parameters

Either `id` or `email` must be provided.

**id** `string`

The Contact ID.

**email** `string`

The Contact Email.

## Query Parameters

**limit** `number`

Number of topics to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more topics (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more topics (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.topics.list({
  id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  // or: email: 'steve.wozniak@gmail.com',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Get by contact id
$resend->contacts->topics->list('e169aa45-1ecf-4183-9955-b1499d5701d3');

// Get by contact email
$resend->contacts->topics->list('steve.wozniak@gmail.com');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

# Get by contact id
topics = resend.Contacts.Topics.list(contact_id='e169aa45-1ecf-4183-9955-b1499d5701d3')

# Get by contact email
topics = resend.Contacts.Topics.list(email='steve.wozniak@gmail.com')
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Get by contact id
contact_topics = Resend::Contacts::Topics.list(id: "e169aa45-1ecf-4183-9955-b1499d5701d3")

# Get by contact email
contact_topics = Resend::Contacts::Topics.list(email: "steve.wozniak@gmail.com")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	// Get by contact id
	topics, err := client.Contacts.Topics.ListWithContext(ctx, "e169aa45-1ecf-4183-9955-b1499d5701d3")
	if err != nil {
		panic(err)
	}
	fmt.Println(topics)

	// Get by contact email
	topics, err = client.Contacts.Topics.ListWithContext(ctx, "steve.wozniak@gmail.com")
	if err != nil {
		panic(err)
	}
	fmt.Println(topics)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _topics = resend
    .contacts
    .get_contact_topics(
      "e169aa45-1ecf-4183-9955-b1499d5701d3",
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    // Get by contact id
    resend.contacts().topics().list("e169aa45-1ecf-4183-9955-b1499d5701d3");

    // Get by contact email
    resend.contacts().topics().list("steve.wozniak@gmail.com");
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactListTopicsAsync( new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ));
Console.WriteLine( "Nr Topics={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
// Get by contact id
curl -X GET 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/topics' \
     -H 'Authorization: Bearer re_xxxxxxxxx'

// Get by contact email
curl -X GET 'https://api.resend.com/contacts/steve.wozniak@gmail.com/topics' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Get by contact id
resend contacts topics e169aa45-1ecf-4183-9955-b1499d5701d3

# Get by contact email
resend contacts topics steve.wozniak@gmail.com
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
      "name": "Product Updates",
      "description": "New features, and latest announcements.",
      "subscription": "opt_in"
    }
  ]
}
```


# List Contact Imports
Source: https://resend.com/docs/api-reference/contacts/list-contact-imports

GET /contacts/imports
Retrieve a list of contact imports.

## Query Parameters

**limit** `number`

Number of contact imports to retrieve.

<ul>
  <li>
    Default value: `10`
  </li>

  <li>
    Maximum value: `100`
  </li>

  <li>
    Minimum value: `1`
  </li>
</ul>

**after** `string`

The contact import ID *after* which we'll retrieve more contact
imports. This ID will *not* be included in the returned list. Cannot be
used with the `before` parameter.

**before** `string`

The contact import ID *before* which we'll retrieve more contact
imports. This ID will *not* be included in the returned list. Cannot be
used with the `after` parameter.

**status** `'queued' | 'in_progress' | 'completed' | 'failed'`

Filter contact imports by status.

> [!NOTE]
>
> You can only use either `after` or `before` parameter,
> not both. See our [pagination guide](/docs/api-reference/pagination) for
> more information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.imports.list({
  limit: 10,
  status: 'completed',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contacts->imports->list([
  'limit' => 10,
  'status' => 'completed',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Contacts.Imports.ListParams = {
    "limit": 10,
    "status": "completed",
}

resend.Contacts.Imports.list(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Contacts::Imports.list(limit: 10, status: "completed")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	limit := 10
	client.Contacts.Imports.List(&resend.ListContactImportsOptions{
		Limit:  &limit,
		Status: string(resend.ContactImportStatusCompleted),
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, Value, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _data = resend
    .contacts
    .list_imports(
      ListOptions::default()
        .with_limit(10)
        .with_other("status", Value::String("completed".to_owned())),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.contacts.model.ListContactImportsParams;
import com.resend.services.contacts.model.ListContactImportsResponseSuccess;

public class Main {
    public static void main(String[] args) throws Exception {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListContactImportsParams params = ListContactImportsParams.builder()
                .limit(10)
                .status("completed")
                .build();

        ListContactImportsResponseSuccess data = resend.contacts().imports().list(params);
    }
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/contacts/imports?limit=10&status=completed' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts imports list --limit 10 --status completed
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "object": "contact_import",
      "id": "479e3145-dd38-476b-932c-529ceb705947",
      "status": "completed",
      "created_at": "2026-05-15 18:32:37.823+00",
      "completed_at": "2026-05-15 18:33:42.916+00",
      "counts": {
        "total": 1200,
        "created": 800,
        "updated": 300,
        "skipped": 75,
        "failed": 25
      }
    }
  ]
}
```


# List Contact Segments
Source: https://resend.com/docs/api-reference/contacts/list-contact-segments

GET /contacts/:contact_id/segments
Retrieve a list of segments that a contact is part of.

## Path Parameters

Either `id` or `email` must be provided.

**id** `string`

The Contact ID.

**email** `string`

The Contact Email.

## Query Parameters

**limit** `number`

Number of segments to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more segments (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more segments (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.segments.list({
  contactId: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contacts->segments->list(
  contactId: 'e169aa45-1ecf-4183-9955-b1499d5701d3'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

params: resend.Contacts.Segments.ListParams = {
    "contact_id": 'e169aa45-1ecf-4183-9955-b1499d5701d3',
}

segments = resend.Contacts.Segments.list(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

segments = Resend::Contacts::Segments.list(
  contact_id: 'e169aa45-1ecf-4183-9955-b1499d5701d3'
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	listParams := &resend.ListContactSegmentsRequest{
		ContactId: "479e3145-dd38-476b-932c-529ceb705947",
	}

	client.Contacts.Segments.List(listParams)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _contacts = resend
    .contacts
    .list_contact_segment(
      "e169aa45-1ecf-4183-9955-b1499d5701d3",
      ListOptions::default()
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    resend.contacts().segments().list("e169aa45-1ecf-4183-9955-b1499d5701d3");
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactListSegmentsAsync( new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ));
Console.WriteLine( "Nr Segments={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/segments' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts segments e169aa45-1ecf-4183-9955-b1499d5701d3
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "data": [
    {
      "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      "name": "Registered Users",
      "created_at": "2026-10-06 22:59:55.977+00"
    }
  ],
  "has_more": false
}
```


# List Contacts
Source: https://resend.com/docs/api-reference/contacts/list-contacts

GET /contacts
Show all contacts.

## Query Parameters

**limit** `number`

Number of contacts to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more contacts (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more contacts (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

**segment\_id** `string`

The Segment ID to filter contacts by. If provided, only contacts in this
Segment will be returned.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contacts->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Contacts.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Contacts.list()
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Contacts.List(&resend.ListContactsOptions{})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _contacts = resend
    .contacts
    .list(
        ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.ListContactsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListContactsResponseSuccess data = resend.contacts().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactListAsync();
Console.WriteLine( "Nr Contacts={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/contacts' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "email": "steve.wozniak@gmail.com",
      "first_name": "Steve",
      "last_name": "Wozniak",
      "created_at": "2026-10-06 23:47:56.678+00",
      "unsubscribed": false
    }
  ]
}
```


# Update Contact
Source: https://resend.com/docs/api-reference/contacts/update-contact

PATCH /contacts/:contact_id
Update an existing contact.

## Path Parameters

Either `id` or `email` must be provided.

**id** `string`

The Contact ID.

**email** `string`

The Contact Email.

## Body Parameters

The first name of the contact.

The last name of the contact.

**unsubscribed** `boolean`

The Contact's global subscription status. If set to `true`, the contact will
be unsubscribed from all Broadcasts.

**properties** `object`

A map of custom property keys and values to update.

**custom properties**

**key** `string` *required*

The property key.

**value** `string | number | boolean | null` *required*

The property value. Use `null` to clear the property value.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.update({
  id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  // or: email: 'acme@example.com',
  unsubscribed: true,
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Update by contact id
$resend->contacts->update(
  idOrEmail: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  parameters: [
    'unsubscribed' => true
  ]
);

// Update by contact email
$resend->contacts->update(
  idOrEmail: 'acme@example.com',
  parameters: [
    'unsubscribed' => true
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Update by contact id
params: resend.Contacts.UpdateParams = {
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "unsubscribed": True,
}

resend.Contacts.update(params)

# Update by contact email
params: resend.Contacts.UpdateParams = {
  "email": "acme@example.com",
  "unsubscribed": True,
}

resend.Contacts.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Update by contact id
params = {
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "unsubscribed": true,
}

Resend::Contacts.update(params)

# Update by contact email
params = {
  "email": "acme@example.com",
  "unsubscribed": true,
}

Resend::Contacts.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Update by contact id
	params := &resend.UpdateContactRequest{
		Id:           "e169aa45-1ecf-4183-9955-b1499d5701d3",
		Unsubscribed: true,
	}

	client.Contacts.Update(params)

	// Update by contact email
	params = &resend.UpdateContactRequest{
		Email:        "acme@example.com",
		Unsubscribed: true,
	}

	client.Contacts.Update(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::ContactChanges, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let changes = ContactChanges::new().with_unsubscribed(true);

  // Update by contact id
  let _contact = resend
    .contacts
    .update("e169aa45-1ecf-4183-9955-b1499d5701d3", changes.clone())
    .await?;

  // Update by contact email
  let _contact = resend
    .contacts
    .update("acme@example.com", changes)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.UpdateContactOptions;
import com.resend.services.contacts.model.UpdateContactResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateContactOptions params = UpdateContactOptions.builder()
                .id("e169aa45-1ecf-4183-9955-b1499d5701d3") // or: .email("acme@example.com")
                .unsubscribed(true)
                .build();

        UpdateContactResponseSuccess data = resend.contacts().update(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// By Id
await resend.ContactUpdateAsync(
    contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
    new ContactData()
    {
        FirstName = "Stevie",
        LastName = "Wozniaks",
        IsUnsubscribed = true,
    }
);

// By Email
await resend.ContactUpdateByEmailAsync(
    "acme@example.com",
    new ContactData()
    {
        FirstName = "Stevie",
        LastName = "Wozniaks",
        IsUnsubscribed = true,
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Update by contact id
curl -X PATCH 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "unsubscribed": true
}'

# Update by contact email
curl -X PATCH 'https://api.resend.com/contacts/acme@example.com' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "unsubscribed": true
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Update by contact id
resend contacts update e169aa45-1ecf-4183-9955-b1499d5701d3 --unsubscribed

# Update by contact email
resend contacts update acme@example.com --unsubscribed
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact",
  "id": "479e3145-dd38-476b-932c-529ceb705947"
}
```


# Update Contact Topics
Source: https://resend.com/docs/api-reference/contacts/update-contact-topics

PATCH /contacts/:contact_id/topics
Update topic subscriptions for a contact.

## Path Parameters

Either `id` or `email` must be provided.

**id** `string`

The Contact ID.

**email** `string`

The Contact Email.

## Body Parameters

**topics** `array` *required*

Array of topic subscription updates.

**properties**

**id** `string` *required*

The Topic ID.

**subscription** `string` *required*

The subscription action. Must be either `opt_in` or `opt_out`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.topics.update({
  id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  // or: email: 'steve.wozniak@gmail.com',
  topics: [
    {
      id: 'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
      subscription: 'opt_out',
    },
    {
      id: '07d84122-7224-4881-9c31-1c048e204602',
      subscription: 'opt_in',
    },
  ],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Update by contact id
$resend->contacts->topics->update('e169aa45-1ecf-4183-9955-b1499d5701d3', [
  [
    'id' => '07d84122-7224-4881-9c31-1c048e204602',
    'subscription' => 'opt_out',
  ],
  [
    'id' => '07d84122-7224-4881-9c31-1c048e204602',
    'subscription' => 'opt_in',
  ],
]);

// Update by contact email
$resend->contacts->topics->update('steve.wozniak@gmail.com', [
  [
    'id' => '07d84122-7224-4881-9c31-1c048e204602',
    'subscription' => 'opt_out',
  ],
  [
    'id' => '07d84122-7224-4881-9c31-1c048e204602',
    'subscription' => 'opt_in',
  ],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

# Update by contact id
params: resend.Contacts.Topics.UpdateParams = {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "topics": [
        {"id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e", "subscription": "opt_out"},
        {"id": "07d84122-7224-4881-9c31-1c048e204602", "subscription": "opt_in"},
    ],
}

response = resend.Contacts.Topics.update(params)

# Update by contact email
params_by_email: resend.Contacts.Topics.UpdateParams = {
    "email": "steve.wozniak@gmail.com",
    "topics": [
        {"id": "07d84122-7224-4881-9c31-1c048e204602", "subscription": "opt_out"},
        {"id": "07d84122-7224-4881-9c31-1c048e204602", "subscription": "opt_in"},
    ],
}

response = resend.Contacts.Topics.update(params_by_email)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Update by contact id
update_params = {
  id: "e169aa45-1ecf-4183-9955-b1499d5701d3",
  topics: [
    { id: "b6d24b8e-af0b-4c3c-be0c-359bbd97381e", subscription: "opt_out" },
    { id: "07d84122-7224-4881-9c31-1c048e204602", subscription: "opt_in" }
  ]
}
updated_topics = Resend::Contacts::Topics.update(update_params)

# Update by contact email
update_params = {
  email: "steve.wozniak@gmail.com",
  topics: [
    { id: "07d84122-7224-4881-9c31-1c048e204602", subscription: "opt_out" },
    { id: "07d84122-7224-4881-9c31-1c048e204602", subscription: "opt_in" }
  ]
}
updated_topics = Resend::Contacts::Topics.update(update_params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	// Update by contact id
	params := &resend.UpdateContactTopicsRequest{
		Id: "e169aa45-1ecf-4183-9955-b1499d5701d3",
		Topics: []resend.TopicSubscriptionUpdate{
			{
				Id:           "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
				Subscription: "opt_out",
			},
			{
				Id:           "07d84122-7224-4881-9c31-1c048e204602",
				Subscription: "opt_in",
			},
		},
	}

	updatedTopics, err := client.Contacts.Topics.UpdateWithContext(ctx, params)
	if err != nil {
		panic(err)
	}
	fmt.Println(updatedTopics)

	// Update by contact email
	params = &resend.UpdateContactTopicsRequest{
		Email: "steve.wozniak@gmail.com",
		Topics: []resend.TopicSubscriptionUpdate{
			{
				Id:           "07d84122-7224-4881-9c31-1c048e204602",
				Subscription: "opt_out",
			},
			{
				Id:           "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
				Subscription: "opt_in",
			},
		},
	}

	updatedTopics, err = client.Contacts.Topics.UpdateWithContext(ctx, params)
	if err != nil {
		panic(err)
	}
	fmt.Println(updatedTopics)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{SubscriptionType, UpdateContactTopicOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let topics = [
    UpdateContactTopicOptions::new(
      "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
      SubscriptionType::OptOut,
    ),
    UpdateContactTopicOptions::new(
      "07d84122-7224-4881-9c31-1c048e204602",
      SubscriptionType::OptIn,
    ),
  ];

  let _contact = resend
    .contacts
    .update_contact_topics("e169aa45-1ecf-4183-9955-b1499d5701d3", topics)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.ContactTopicOptions;
import com.resend.services.contacts.model.UpdateContactTopicsOptions;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    // Update by contact id
    UpdateContactTopicsOptions optionsById = UpdateContactTopicsOptions.builder()
                .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
                .topics(ContactTopicOptions.builder()
                            .id("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
                            .subscription("opt_out")
                            .build(),
                        ContactTopicOptions.builder()
                            .id("07d84122-7224-4881-9c31-1c048e204602")
                            .subscription("opt_in")
                            .build())
                .build();

    resend.contacts().topics().update(optionsById);

    // Update by contact email
    UpdateContactTopicsOptions optionsByEmail = UpdateContactTopicsOptions.builder()
                .email("steve.wozniak@gmail.com")
                .topics(ContactTopicOptions.builder()
                            .id("07d84122-7224-4881-9c31-1c048e204602")
                            .subscription("opt_in")
                            .build(),
                        ContactTopicOptions.builder()
                            .id("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
                            .subscription("opt_out")
                            .build())
                .build();

    resend.contacts().topics().update(optionsByEmail);
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var topics = new List<TopicSubscription>();

topics.Add( new TopicSubscription() {
  Id = new Guid( "07d84122-7224-4881-9c31-1c048e204602" ),
  Subscription = SubscriptionType.OptIn,
});

topics.Add( new TopicSubscription() {
  Id = new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ),
  Subscription = SubscriptionType.OptOut,
});

await resend.ContactUpdateTopicsAsync(
    new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
    topics );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
// Update by contact id
curl -X PATCH 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/topics' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'[
      {
        "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
        "subscription": "opt_out"
      }
     ]'

// Update by contact email
curl -X PATCH 'https://api.resend.com/contacts/steve.wozniak@gmail.com/topics' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'[
      {
        "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
        "subscription": "opt_out"
      }
     ]'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Update by contact id
resend contacts update-topics e169aa45-1ecf-4183-9955-b1499d5701d3 \
  --topics '[{"id":"b6d24b8e-af0b-4c3c-be0c-359bbd97381e","subscription":"opt_out"}]'

# Update by contact email
resend contacts update-topics steve.wozniak@gmail.com \
  --topics '[{"id":"b6d24b8e-af0b-4c3c-be0c-359bbd97381e","subscription":"opt_out"}]'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "contact_topics",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
}
```


# Claim Domain
Source: https://resend.com/docs/api-reference/domains/claim-domain

POST /domains/claim
Claim a domain that is already verified by another team.

> [!NOTE]
>
> Use this endpoint when [creating a
> domain](/docs/api-reference/domains/create-domain) fails because the domain is
> already verified by another team. Resend creates a placeholder domain on your
> team and returns a `domain_claim` with a TXT record to add to your DNS. Learn
> more in [Claiming a domain](/docs/dashboard/domains/claim).

## Body Parameters

**name** `string` *required*

The name of the domain you want to claim.

**region** `string` (default: us-east-1)

The region where emails will be sent from. Possible values: `'us-east-1' |
    'eu-west-1' | 'sa-east-1' | 'ap-northeast-1'`

Choose a subdomain for the Return-Path address. Defaults to `send` (i.e.,
`send.yourdomain.tld`). Avoid setting values that could undermine credibility
(e.g. `testing`), as they may be exposed to recipients.

Track the open rate of each email.

> [!NOTE]
>
> This setting is only applied if a `tracking_subdomain` is configured and verified.

Track clicks within the body of each HTML email.

> [!NOTE]
>
> This setting is only applied if a `tracking_subdomain` is configured and verified.

Configure a custom subdomain for click and open tracking. For example, setting
`"links"` on domain `example.com` will produce a CNAME record for
`links.example.com`. Avoid setting values that have a negative connotation (e.g. `tracking`).

Learn more about [custom tracking subdomains](/docs/dashboard/domains/tracking).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.claims.create({
  name: 'example.com',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->claims->create([
  'name' => 'example.com'
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Domains.Claims.CreateParams = {
  "name": "example.com",
}

resend.Domains.Claims.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "example.com",
}
claim = Resend::Domains::Claims.create(params)
puts claim
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateDomainClaimRequest{
		Name: "example.com",
	}

	client.DomainClaims.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, types::CreateDomainClaimOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let domain_claim = CreateDomainClaimOptions::new("example.com");
  let _data = resend.domains.claim(domain_claim).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.domains.model.ClaimDomainOptions;
import com.resend.services.domains.model.DomainClaimResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ClaimDomainOptions params = ClaimDomainOptions
                .builder()
                .name("example.com").build();

        DomainClaimResponseSuccess claim = resend.domains().claims().create(params);
    }
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/domains/claim' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "example.com"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains claim create --name example.com
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "domain_claim",
  "id": "dacf4072-4119-4d88-932f-6c6126d3a9d1",
  "name": "example.com",
  "status": "pending",
  "domain_id": "d91cd9bd-1176-453e-8fc1-35364d380206",
  "region": "us-east-1",
  "record": {
    "type": "TXT",
    "name": "example.com",
    "value": "resend-domain-verification=3f8a1c2d4e5b6a7f8091a2b3c4d5e6f7",
    "ttl": "Auto"
  },
  "blocked_reason": null,
  "failure_reason": null,
  "created_at": "2026-06-16 17:12:02.059593+00",
  "expires_at": "2026-06-23 17:12:02.059593+00"
}
```


# Create Domain
Source: https://resend.com/docs/api-reference/domains/create-domain

POST /domains
Create a domain through the Resend Email API.

## Body Parameters

**name** `string` *required*

The name of the domain you want to create.

**region** `string` (default: us-east-1)

The region where emails will be sent from. Possible values: `'us-east-1' |
    'eu-west-1' | 'sa-east-1' | 'ap-northeast-1'`

For advanced use cases, choose a subdomain for the Return-Path address. The
custom return path is used for SPF authentication, DMARC alignment, and
handling bounced emails. Defaults to `send` (i.e., `send.yourdomain.tld`). Avoid
setting values that could undermine credibility (e.g. `testing`), as they may
be exposed to recipients.

Learn more about [custom return paths](/docs/dashboard/domains/custom-return-path).

Track the open rate of each email.

> [!NOTE]
>
> This setting is only applied if a `tracking_subdomain` is configured and verified.

Track clicks within the body of each HTML email.

> [!NOTE]
>
> This setting is only applied if a `tracking_subdomain` is configured and verified.

Configure a custom subdomain for click and open tracking. For example, setting
`"links"` on domain `example.com` will produce a CNAME record for
`links.example.com`. Avoid setting values that have a negative connotation (e.g. `tracking`).

Learn more about [custom tracking subdomains](/docs/dashboard/domains/tracking).

**tls** `string` (default: opportunistic)

<ul>
  <li>
    `opportunistic`: Opportunistic TLS means that it always attempts to make a
    secure connection to the receiving mail server. If it can't establish a
    secure connection, it sends the message unencrypted.
  </li>

  <li>
    `enforced`: Enforced TLS on the other hand, requires that the email
    communication must use TLS no matter what. If the receiving server does
    not support TLS, the email will not be sent.
  </li>
</ul>

**capabilities** `object`

Configure the domain capabilities for sending and receiving emails. At least one capability must be enabled.

**properties**

**sending** `string` (default: enabled)

Enable or disable sending emails from this domain. Possible values: `'enabled' | 'disabled'`

**receiving** `string` (default: disabled)

Enable or disable receiving emails to this domain. Possible values: `'enabled' | 'disabled'`

> [!NOTE]
>
> See all available [domain `status`
> types](/docs/dashboard/domains/manage-domains#understand-a-domain-status).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.create({ name: 'example.com' });
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->create([
  'name' => 'example.com'
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Domains.CreateParams = {
  "name": "example.com",
}

resend.Domains.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "example.com",
}
domain = Resend::Domains.create(params)
puts domain
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateDomainRequest{
		Name: "example.com",
	}

	client.Domains.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateDomainOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _domain = resend
    .domains
    .create(CreateDomainOptions::new("example.com"))
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.domains.model.CreateDomainOptions;
import com.resend.services.domains.model.CreateDomainResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateDomainOptions params = CreateDomainOptions
                .builder()
                .name("example.com").build();

        CreateDomainResponse domain = resend.domains().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.DomainAddAsync( "example.com" );
Console.WriteLine( "Domain Id={0}", resp.Content.Id );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/domains' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "example.com"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains create --name example.com --region us-east-1
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
  "name": "example.com",
  "created_at": "2026-03-28 17:12:02.059593+00",
  "status": "not_started",
  "open_tracking": true,
  "click_tracking": false,
  "tracking_subdomain": "links",
  "capabilities": {
    "sending": "enabled",
    "receiving": "disabled"
  },
  "records": [
    {
      "record": "DKIM",
      "name": "resend._domainkey",
      "value": "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsc4Lh8xilsngyKEgN2S84+21gn+x6SEXtjWvPiAAmnmggr5FWG42WnqczpzQ/mNblqHz4CDwUum6LtY6SdoOlDmrhvp5khA3cd661W9FlK3yp7+jVACQElS7d9O6jv8VsBbVg4COess3gyLE5RyxqF1vYsrEXqyM8TBz1n5AGkQIDAQA2",
      "type": "TXT",
      "status": "not_started",
      "ttl": "Auto"
    },
    {
      "record": "SPF",
      "name": "send",
      "type": "MX",
      "ttl": "Auto",
      "status": "not_started",
      "value": "feedback-smtp.us-east-1.amazonses.com",
      "priority": 10
    },
    {
      "record": "SPF",
      "name": "send",
      "value": "v=spf1 include:amazonses.com ~all",
      "type": "TXT",
      "ttl": "Auto",
      "status": "not_started"
    },
    {
      "record": "Tracking",
      "type": "CNAME",
      "name": "links",
      "value": "links1.resend-dns.com",
      "ttl": "Auto",
      "status": "not_started"
    }
  ],
  "region": "us-east-1"
}
```


# Delete Domain
Source: https://resend.com/docs/api-reference/domains/delete-domain

DELETE /domains/:domain_id
Remove an existing domain.

> [!WARNING]
>
> Removing a domain with a configured [custom tracking subdomain](/docs/dashboard/domains/tracking)
> will also remove the Resend provisioned proxy, breaking any existing email links that use that subdomain.
>
> To keep links working, set up your own proxy pointing to Resend’s tracking DNS records before removing the domain.

## Path Parameters

The Domain ID.

```js Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.remove(
  'd91cd9bd-1176-453e-8fc1-35364d380206',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->remove('d91cd9bd-1176-453e-8fc1-35364d380206');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Domains.remove(domain_id="d91cd9bd-1176-453e-8fc1-35364d380206")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Domains.remove("d91cd9bd-1176-453e-8fc1-35364d380206")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Domains.Remove("d91cd9bd-1176-453e-8fc1-35364d380206")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .domains
    .delete("d91cd9bd-1176-453e-8fc1-35364d380206")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.domains.model.RemoveDomainResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveDomainResponse removed = resend.domains().remove("d91cd9bd-1176-453e-8fc1-35364d380206");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.DomainDeleteAsync( new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains delete d91cd9bd-1176-453e-8fc1-35364d380206
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "domain",
  "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
  "deleted": true
}
```


# Retrieve Domain
Source: https://resend.com/docs/api-reference/domains/get-domain

GET /domains/:domain_id
Retrieve a single domain for the authenticated user.

## Path Parameters

The Domain ID.

> [!NOTE]
>
> See all available [domain `status`
> types](/docs/dashboard/domains/manage-domains#understand-a-domain-status).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.get(
  'd91cd9bd-1176-453e-8fc1-35364d380206',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->get('d91cd9bd-1176-453e-8fc1-35364d380206');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Domains.get(domain_id="d91cd9bd-1176-453e-8fc1-35364d380206")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Domains.get "d91cd9bd-1176-453e-8fc1-35364d380206"
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Domains.Get("d91cd9bd-1176-453e-8fc1-35364d380206")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _domain = resend
    .domains
    .get("d91cd9bd-1176-453e-8fc1-35364d380206")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.domains.model.Domain;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Domain domain = resend.domains().get("d91cd9bd-1176-453e-8fc1-35364d380206");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.DomainRetrieveAsync( new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ) );
Console.WriteLine( "Domain Id={0}", resp.Content.Name );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains get d91cd9bd-1176-453e-8fc1-35364d380206
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "domain",
  "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
  "name": "example.com",
  "status": "not_started",
  "created_at": "2026-04-26 20:21:26.347412+00",
  "region": "us-east-1",
  "open_tracking": true,
  "click_tracking": false,
  "tracking_subdomain": "links",
  "capabilities": {
    "sending": "enabled",
    "receiving": "disabled"
  },
  "records": [
    {
      "record": "SPF",
      "name": "send",
      "type": "MX",
      "ttl": "Auto",
      "status": "not_started",
      "value": "feedback-smtp.us-east-1.amazonses.com",
      "priority": 10
    },
    {
      "record": "SPF",
      "name": "send",
      "value": "\"v=spf1 include:amazonses.com ~all\"",
      "type": "TXT",
      "ttl": "Auto",
      "status": "not_started"
    },
    {
      "record": "DKIM",
      "name": "resend._domainkey",
      "value": "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsc4Lh8xilsngyKEgN2S84+21gn+x6SEXtjWvPiAAmnmggr5FWG42WnqczpzQ/mNblqHz4CDwUum6LtY6SdoOlDmrhvp5khA3cd661W9FlK3yp7+jVACQElS7d9O6jv8VsBbVg4COess3gyLE5RyxqF1vYsrEXqyM8TBz1n5AGkQIDAQA2",
      "type": "TXT",
      "status": "not_started",
      "ttl": "Auto"
    },
    {
      "record": "Tracking",
      "name": "links.example.com",
      "type": "CNAME",
      "value": "links1.resend-dns.com",
      "ttl": "Auto",
      "status": "not_started"
    }
  ]
}
```


# Retrieve Domain Claim
Source: https://resend.com/docs/api-reference/domains/get-domain-claim

GET /domains/:domain_id/claim
Retrieve the latest claim for a domain.

> [!NOTE]
>
> Poll this endpoint to follow a claim's `status` after you [start a
> claim](/docs/api-reference/domains/claim-domain). The `domain_id` is the
> placeholder domain id returned in the `domain_claim` object.

## Path Parameters

The placeholder Domain ID returned when the claim was created.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.claims.get(
  'd91cd9bd-1176-453e-8fc1-35364d380206',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->claims->get(
  'd91cd9bd-1176-453e-8fc1-35364d380206'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Domains.Claims.get(domain_id="d91cd9bd-1176-453e-8fc1-35364d380206")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

claim = Resend::Domains::Claims.get("d91cd9bd-1176-453e-8fc1-35364d380206")
puts claim
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.DomainClaims.Get("d91cd9bd-1176-453e-8fc1-35364d380206")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _data = resend
    .domains
    .get_claim("d91cd9bd-1176-453e-8fc1-35364d380206")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.domains.model.DomainClaimResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        DomainClaimResponseSuccess claim = resend.domains().claims()
                .get("d91cd9bd-1176-453e-8fc1-35364d380206");
    }
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206/claim' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains claim get d91cd9bd-1176-453e-8fc1-35364d380206
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "domain_claim",
  "id": "dacf4072-4119-4d88-932f-6c6126d3a9d1",
  "name": "example.com",
  "status": "pending",
  "domain_id": "d91cd9bd-1176-453e-8fc1-35364d380206",
  "region": "us-east-1",
  "record": {
    "type": "TXT",
    "name": "example.com",
    "value": "resend-domain-verification=3f8a1c2d4e5b6a7f8091a2b3c4d5e6f7",
    "ttl": "Auto"
  },
  "blocked_reason": null,
  "failure_reason": null,
  "created_at": "2026-06-16 17:12:02.059593+00",
  "expires_at": "2026-06-23 17:12:02.059593+00"
}
```


# List Domains
Source: https://resend.com/docs/api-reference/domains/list-domains

GET /domains
Retrieve a list of domains for the authenticated user.

> [!NOTE]
>
> See all available [domain `status`
> types](/docs/dashboard/domains/manage-domains#understand-a-domain-status).

## Query Parameters

If `limit` is not provided, all domains will be returned
in a single response. Pass `limit` to paginate.
`after` and `before` only take effect together
with `limit`.

**limit** `number`

Number of domains to retrieve.
<ul><li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more domains (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more domains (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"
resend.Domains.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Domains.list
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Domains.List()
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _domains = resend.domains.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.domains.model.ListDomainsResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListDomainsResponse response = resend.domains().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.DomainListAsync();
Console.WriteLine( "Nr Domains={0}", resp.Content.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/domains' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
      "name": "example.com",
      "status": "not_started",
      "created_at": "2026-04-26 20:21:26.347412+00",
      "region": "us-east-1",
      "open_tracking": true,
      "click_tracking": false,
      "capabilities": {
        "sending": "enabled",
        "receiving": "disabled"
      }
    }
  ]
}
```


# Update Domain
Source: https://resend.com/docs/api-reference/domains/update-domain

PATCH /domains/:domain_id
Update an existing domain.

## Path Parameters

The Domain ID.

## Body Parameters

Track clicks within the body of each HTML email.

> [!NOTE]
>
> This setting is only applied if a `tracking_subdomain` is configured and verified.

Track the open rate of each email.

> [!NOTE]
>
> This setting is only applied if a `tracking_subdomain` is configured and verified.

Configure a custom subdomain for click and open tracking. For example, setting
`"links"` on domain `example.com` will produce a CNAME record for
`links.example.com`. Avoid setting values that have a negative connotation (e.g. `tracking`).

This value can only be changed after it has been specified, never removed. This is to preserve any email links that
may already be sent with the current tracking subdomain.

After changing the tracking subdomain, a new DNS record must be verified, until then, the previous value is used.
Do not remove old tracking DNS records, all previously used records remain active and are included in the response.

Learn more about [custom tracking subdomains](/docs/dashboard/domains/tracking).

**tls** `string` (default: opportunistic)

<ul>
  <li>
    `opportunistic`: Opportunistic TLS means that it always attempts to make a
    secure connection to the receiving mail server. If it can't establish a
    secure connection, it sends the message unencrypted.
  </li>

  <li>
    `enforced`: Enforced TLS on the other hand, requires that the email
    communication must use TLS no matter what. If the receiving server does
    not support TLS, the email will not be sent.
  </li>
</ul>

**capabilities** `object`

Update the domain capabilities for sending and receiving emails. You can specify one or both fields. Omitted fields will keep their current value. At least one capability must remain enabled.

**properties**

**sending** `string`

Enable or disable sending emails from this domain. Possible values: `'enabled' | 'disabled'`

**receiving** `string`

Enable or disable receiving emails to this domain. Possible values: `'enabled' | 'disabled'`

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.update({
  id: 'b8617ad3-b712-41d9-81a0-f7c3d879314e',
  openTracking: false,
  clickTracking: true,
  trackingSubdomain: 'links',
  tls: 'enforced',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->update(
  'b8617ad3-b712-41d9-81a0-f7c3d879314e',
  [
    'open_tracking' => false,
    'click_tracking' => true,
    'tracking_subdomain' => 'links',
    'tls' => 'enforced',
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Domains.UpdateParams = {
  "id": "b8617ad3-b712-41d9-81a0-f7c3d879314e",
  "open_tracking": False,
  "click_tracking": True,
  "tracking_subdomain": "links",
  "tls": "enforced",
}

resend.Domains.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Domains.update({
  id: "b8617ad3-b712-41d9-81a0-f7c3d879314e",
  open_tracking: false,
  click_tracking: true,
  tracking_subdomain: "links",
  tls: "enforced",
})
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	updateDomainParams := &resend.UpdateDomainRequest{
		OpenTracking:      false,
		ClickTracking:     true,
		TrackingSubdomain: "links",
		Tls:               resend.Enforced,
	}

	client.Domains.Update("b8617ad3-b712-41d9-81a0-f7c3d879314e", updateDomainParams)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::{DomainChanges, Tls}, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let changes = DomainChanges::new()
    .with_open_tracking(false)
    .with_click_tracking(true)
    .with_tracking_subdomain("links")
    .with_tls(Tls::Enforced);

  let _domain = resend
    .domains
    .update("b8617ad3-b712-41d9-81a0-f7c3d879314e", changes)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.services.domains.model.Tls;
import com.resend.services.domains.model.UpdateDomainOptions;

Resend resend = new Resend("re_xxxxxxxxx");

UpdateDomainOptions params = UpdateDomainOptions.builder()
                .id("b8617ad3-b712-41d9-81a0-f7c3d879314e")
                .openTracking(false)
                .clickTracking(true)
                .trackingSubdomain("links")
                .tls(Tls.ENFORCED)
                .build();

resend.domains().update(params);
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.DomainUpdateAsync(
    new Guid( "b8617ad3-b712-41d9-81a0-f7c3d879314e" ),
    new DomainUpdateData()
    {
        TrackOpen = false,
        TrackClicks = true,
        TrackingSubdomain = "links",
        TlsMode = TlsMode.Enforced,
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/domains/b8617ad3-b712-41d9-81a0-f7c3d879314e' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "open_tracking": false,
  "click_tracking": true,
  "tracking_subdomain": "links",
  "tls": "enforced"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains update b8617ad3-b712-41d9-81a0-f7c3d879314e \
  --no-open-tracking \
  --click-tracking \
  --tracking-subdomain links \
  --tls enforced
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "domain",
  "id": "b8617ad3-b712-41d9-81a0-f7c3d879314e"
}
```


# Verify Domain
Source: https://resend.com/docs/api-reference/domains/verify-domain

POST /domains/:domain_id/verify
Verify an existing domain.

> [!NOTE]
>
> Calling this API endpoint triggers an **asynchronous domain verification
> process**. Records that are already verified stay `verified` while the
> verification is in progress, so sending and receiving are not interrupted.
> Records that are not verified are marked as `pending`. If a verified record is
> no longer found, it is marked as `failed` once the verification times out.
> Since this request initiates the complete domain verification cycle, it will
> trigger `domain.updated` webhook events as the domain status changes during
> the verification process.

> [!NOTE]
>
> **Claimed a domain?** A [domain claim](/docs/dashboard/domains/claim) transfers the
> domain into your account as a brand-new domain with its own DKIM keys, so the
> previous account's DNS records can't be reused. After the claim is
> `completed`, fetch the domain with [Retrieve
> Domain](/docs/api-reference/domains/get-domain), update your DNS with the new DKIM
> record(s) it returns, then call this endpoint to verify it before sending or
> receiving email. See [DKIM
> records](/docs/dashboard/domains/manage-domains#what-are-dkim-records) for details.

## Path Parameters

The Domain ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.verify(
  'd91cd9bd-1176-453e-8fc1-35364d380206',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->verify('d91cd9bd-1176-453e-8fc1-35364d380206');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"
resend.Domains.verify(domain_id="d91cd9bd-1176-453e-8fc1-35364d380206")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Domains.verify("d91cd9bd-1176-453e-8fc1-35364d380206")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Domains.Verify("d91cd9bd-1176-453e-8fc1-35364d380206")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  resend
    .domains
    .verify("d91cd9bd-1176-453e-8fc1-35364d380206")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.domains.model.VerifyDomainResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        VerifyDomainResponse verified = resend.domains().verify("d91cd9bd-1176-453e-8fc1-35364d380206");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.DomainVerifyAsync( new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206/verify' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains verify d91cd9bd-1176-453e-8fc1-35364d380206
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "domain",
  "id": "d91cd9bd-1176-453e-8fc1-35364d380206"
}
```


# Verify Domain Claim
Source: https://resend.com/docs/api-reference/domains/verify-domain-claim

POST /domains/:domain_id/claim/verify
Trigger DNS verification for a domain claim.

> [!NOTE]
>
> Calling this endpoint starts an **asynchronous verification process**. Resend
> checks the claim's TXT record and runs ownership-safety checks before
> transferring the domain to your team. Add the TXT record returned by [Claim
> Domain](/docs/api-reference/domains/claim-domain) before calling this, then poll
> [Retrieve Domain Claim](/docs/api-reference/domains/get-domain-claim) to follow the
> `status`.

> [!NOTE]
>
> **After the claim completes:** the domain is transferred to your account as a
> brand-new domain with its own DKIM keys, so the previous account's DNS records
> can't be reused. Fetch it with [Retrieve
> Domain](/docs/api-reference/domains/get-domain), update your DNS with the new DKIM
> record(s), then run [Verify Domain](/docs/api-reference/domains/verify-domain) to
> finish setup before sending or receiving email. See [DKIM
> records](/docs/dashboard/domains/manage-domains#what-are-dkim-records) for details.

## Path Parameters

The placeholder Domain ID returned when the claim was created.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.claims.verify(
  'd91cd9bd-1176-453e-8fc1-35364d380206',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->claims->verify(
  'd91cd9bd-1176-453e-8fc1-35364d380206'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Domains.Claims.verify(domain_id="d91cd9bd-1176-453e-8fc1-35364d380206")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

claim = Resend::Domains::Claims.verify("d91cd9bd-1176-453e-8fc1-35364d380206")
puts claim
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.DomainClaims.Verify("d91cd9bd-1176-453e-8fc1-35364d380206")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _data = resend
    .domains
    .verify_claim("d91cd9bd-1176-453e-8fc1-35364d380206")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.domains.model.DomainClaimResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        DomainClaimResponseSuccess claim = resend.domains().claims()
                .verify("d91cd9bd-1176-453e-8fc1-35364d380206");
    }
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206/claim/verify' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains claim verify d91cd9bd-1176-453e-8fc1-35364d380206
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "domain_claim",
  "id": "dacf4072-4119-4d88-932f-6c6126d3a9d1",
  "name": "example.com",
  "status": "pending",
  "domain_id": "d91cd9bd-1176-453e-8fc1-35364d380206",
  "region": "us-east-1",
  "record": {
    "type": "TXT",
    "name": "example.com",
    "value": "resend-domain-verification=3f8a1c2d4e5b6a7f8091a2b3c4d5e6f7",
    "ttl": "Auto"
  },
  "blocked_reason": null,
  "failure_reason": null,
  "created_at": "2026-06-16 17:12:02.059593+00",
  "expires_at": "2026-06-23 17:12:02.059593+00"
}
```


# Cancel Email
Source: https://resend.com/docs/api-reference/emails/cancel-email

POST /emails/:email_id/cancel
Cancel a scheduled email.

## Path Parameters

**id** `string` *required*

The Email ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.cancel(
  '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->cancel('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"
resend.Emails.cancel(email_id="49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Emails.cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	canceled, err := client.Emails.Cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
	if err != nil {
		panic(err)
	}
	fmt.Println(canceled.Id)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _canceled = resend
    .emails
    .cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CancelEmailResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CancelEmailResponse canceled = resend
          .emails()
          .cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.EmailCancelAsync( new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794/cancel' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails cancel 49a3999c-0ce1-4ea6-ab68-afcd6dc2e794
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "email",
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
}
```


# Retrieve Metrics
Source: https://resend.com/docs/api-reference/emails/get-metrics

GET /emails/metrics
Retrieve account-level email metrics.

> [!NOTE]
>
> Metrics are retained according to your plan's data retention window.
> Requesting a `start_date` older than your retention window returns data
> clamped to the oldest date your plan retains. This doesn't apply when
> `broadcast_id` is set.

> [!NOTE]
>
> Responses are cached for up to 15 minutes, so a request for the same range may
> return slightly stale data within that window.

All parameters are optional. With none, the response covers the last 7 days
(today plus the 6 previous days), includes every metric, and returns only
`totals`.

## Query Parameters

List-type query parameters below accept a comma-separated value, the
parameter repeated (`domain_id=a&domain_id=b`), or a mix of
both.

**start\_date** `string`

The start of the date range, as an ISO 8601 date (`2026-07-01`) or datetime
(`2026-07-01T00:00:00Z`). Must be on or before `end_date`, and can equal it to
query a single day. Defaults to 6 days before `end_date`.

**end\_date** `string`

The end of the date range, as an ISO 8601 date or datetime. Values in the
future are clamped to the current time. Defaults to now.

**timezone** `string` (default: UTC)

The IANA timezone (e.g. `America/New_York`) used to bucket periods when
`period` is in `dimensions`.

**granularity** `hourly | daily | weekly | monthly` (default: daily)

The bucket size used when `period` is in `dimensions`. Accepted but has no
effect otherwise. The date range can't produce more than 10,000 periods at the
chosen granularity. This limit only applies when `period` is in `dimensions`.

**metrics** `string[]`

List of metrics to include in the response. Omit for all. See
[Metrics](#metrics).

**dimensions** `string[]` (default: \[])

List of dimensions to break the response down by. Combine
any of `period`, `domain`, `email`, or `broadcast` to group the data by
more than one at once, except `email` cannot be combined with `broadcast`.
Omit for a single `totals` row for the whole range, with no `data`.

Possible values:

* `period`: groups the data by `granularity` period, in chronological order.
* `domain`: groups the data by sending domain.
* `email`: groups the data by email. Cannot be combined with `broadcast`.
* `broadcast`: groups the data by broadcast. Cannot be combined with `email`.

**domain\_id** `string[]`

List of sending domain IDs to restrict the response to, up to 100.

**email\_id** `string[]`

List of email IDs to restrict the response to, up to 100. Cannot be combined
with the `broadcast` dimension or `broadcast_id`.

**broadcast\_id** `string[]`

List of broadcast IDs to restrict the response to, up to 100. Cannot be
combined with the `email` dimension or `email_id`.

> [!TIP]
>
> For a 24-hour breakdown of one day, set `start_date` and `end_date` to the
> same date, with `granularity=hourly` and `period` in `dimensions`.

## Metrics

| Metric | Description |
| - | - |
| `received` | Emails Resend accepted for processing. |
| `sent` | Emails sent to the recipient's mail server. |
| `delivered` | Emails the recipient's mail server accepted. |
| `delivery_delayed` | Delivery postponed by a temporary issue. Not final. |
| `failed` | Emails that never reached a mail server. |
| `suppressed` | Skipped because the recipient is [suppressed](/docs/dashboard/emails/email-suppressions). |
| `bounced` | All [bounces](/docs/dashboard/emails/email-bounces), summing the three below. |
| `bounced_transient` | Soft bounce. Temporary, so a later send can succeed. |
| `bounced_permanent` | Hard bounce. Permanent, and the address is suppressed. |
| `bounced_undetermined` | Bounce with no classifiable reason. |
| `opened` | Open events, including repeats. |
| `unique_opened` | Emails opened at least once. |
| `clicked` | Link click events, including repeats. |
| `unique_clicked` | Emails clicked at least once. |
| `complained` | Delivered emails marked as spam. |
| `unsubscribed` | Recipients who unsubscribed. |
| `delivery_rate` | `delivered` / `sent` |
| `open_rate` | `unique_opened` / `delivered` |
| `click_rate` | `unique_clicked` / `delivered` |
| `bounce_rate` | `bounced` / `sent` |
| `complaint_rate` | `complained` / `delivered` |
| `unsubscribe_rate` | `unsubscribed` / `delivered` |

> [!NOTE]
>
> Open and click metrics require [open and click
> tracking](/docs/dashboard/domains/tracking) on the sending domain.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data } = await resend.emails.metrics({
  startDate: '2026-07-01',
  endDate: '2026-07-08',
  metrics: ['sent', 'delivered', 'open_rate'],
  dimensions: ['period', 'broadcast'],
  broadcastId: ['5a5a3b1e-3b1a-4b1a-8b1a-3b1a4b1a8b1a'],
});
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Emails.MetricsParams = {
  "start_date": "2026-07-01",
  "end_date": "2026-07-08",
  "metrics": ["sent", "delivered", "open_rate"],
  "dimensions": ["period", "broadcast"],
  "broadcast_id": ["5a5a3b1e-3b1a-4b1a-8b1a-3b1a4b1a8b1a"],
}

metrics = resend.Emails.metrics(params)
print(metrics)
```

```rb Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  start_date: "2026-07-01",
  end_date: "2026-07-08",
  metrics: ["sent", "delivered", "open_rate"],
  dimensions: ["period", "broadcast"],
  broadcast_id: ["5a5a3b1e-3b1a-4b1a-8b1a-3b1a4b1a8b1a"]
}

metrics = Resend::Emails.metrics(params)
puts metrics
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  startDate := "2026-07-01"
  endDate := "2026-07-08"

  metrics, err := client.Emails.MetricsWithOptions(ctx, &resend.MetricsOptions{
    StartDate: &startDate,
    EndDate:   &endDate,
    Metrics: []resend.MetricName{
      resend.MetricSent,
      resend.MetricDelivered,
      resend.MetricOpenRate,
    },
    Dimensions: []resend.MetricsDimension{
      resend.MetricsDimensionPeriod,
      resend.MetricsDimensionBroadcast,
    },
    BroadcastId: []string{"5a5a3b1e-3b1a-4b1a-8b1a-3b1a4b1a8b1a"},
  })

  if err != nil {
    panic(err)
  }
  fmt.Println(metrics.Totals)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::{GetEmailMetricsOptions, Metric};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let options = GetEmailMetricsOptions::default()
    .with_start_date("2026-07-01")
    .with_end_date("2026-07-08")
    .with_metrics([Metric::Sent, Metric::Delivered, Metric::OpenRate])
    .with_period_dimension()
    .with_broadcast_dimension()
    .with_broadcast_id("5a5a3b1e-3b1a-4b1a-8b1a-3b1a4b1a8b1a");

  let _metrics = resend.emails.metrics(options).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.*;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetEmailsMetricsOptions options = GetEmailsMetricsOptions.builder()
                .startDate("2026-07-01")
                .endDate("2026-07-08")
                .metrics(MetricName.SENT, MetricName.DELIVERED, MetricName.OPEN_RATE)
                .dimensions(MetricsDimension.PERIOD, MetricsDimension.BROADCAST)
                .broadcastIds("5a5a3b1e-3b1a-4b1a-8b1a-3b1a4b1a8b1a")
                .build();

        EmailsMetricsResponse metrics = resend.emails().metrics(options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.EmailMetricsAsync( new EmailMetricsQuery()
{
    StartDate = new DateTime( 2026, 7, 1 ),
    EndDate = new DateTime( 2026, 7, 8 ),
    Metrics = new List<MetricType> { MetricType.Sent, MetricType.Delivered, MetricType.OpenRate },
    Dimensions = new List<MetricDimension> { MetricDimension.Period, MetricDimension.Broadcast },
    BroadcastId = new List<Guid> { Guid.Parse( "5a5a3b1e-3b1a-4b1a-8b1a-3b1a4b1a8b1a" ) },
} );
Console.WriteLine( "Totals={0}", resp.Content?.Totals );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/emails/metrics?start_date=2026-07-01&end_date=2026-07-08&metrics=sent,delivered,open_rate&dimensions=period,domain' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "metrics",
  "start_date": "2026-07-01T00:00:00.000Z",
  "end_date": "2026-07-08T00:00:00.000Z",
  "metrics": ["sent", "delivered", "open_rate"],
  "dimensions": ["period", "domain"],
  "granularity": "daily",
  "totals": {
    "sent": 1204,
    "delivered": 1180,
    "open_rate": 50.0
  },
  "data": [
    {
      "period": "2026-07-01",
      "domain_id": "d91cd9bd-1176-4f47-2a4b-fce2d5399cbf",
      "domain_name": "example.com",
      "sent": 172,
      "delivered": 169,
      "open_rate": 49.7
    }
  ]
}
```


# List Attachments
Source: https://resend.com/docs/api-reference/emails/list-email-attachments

GET /emails/:email_id/attachments
Retrieve a list of attachments from a sent email.

## Query Parameters

**limit** `number`

Number of attachments to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more attachments (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more attachments (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

## Path Parameters

**email\_id** `string` *required*

The Email ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.attachments.list({
  emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->attachments->list(
  emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

attachments = resend.Emails.Attachments.list(
  email_id='4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

Resend::Emails::Attachments.list(
  email_id: "4ef9a417-02e9-4d39-ad75-9611e0fcc33c"
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Emails.ListAttachmentsWithContext(
		context.TODO(),
		"4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _email = resend
    .emails
    .list_attachments(
      "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.ListAttachmentsResponse;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    ListAttachmentsResponse response = resend.emails().listAttachments(
      "4ef9a417-02e9-4d39-ad75-9611e0fcc33c"
    );
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailAttachmentListAsync( new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ));
Console.WriteLine( "Nr Attachments={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/emails/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails attachments 4ef9a417-02e9-4d39-ad75-9611e0fcc33c
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
      "filename": "avatar.png",
      "size": 4096,
      "content_type": "image/png",
      "content_disposition": "inline",
      "content_id": "img001",
      "download_url": "https://outbound-cdn.resend.com/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318?some-params=example&signature=sig-123",
      "expires_at": "2026-10-17T14:29:41.521Z"
    }
  ]
}
```


# List Sent Emails
Source: https://resend.com/docs/api-reference/emails/list-emails

GET /emails
Retrieve a list of emails sent by your team.

You can list all emails sent by your team. The list returns references to individual emails. If needed, you can use the `id` of an email to retrieve the email HTML to plain text using the [Retrieve Email](/docs/api-reference/emails/retrieve-email) endpoint or the [Retrieve Attachments](/docs/api-reference/emails/list-email-attachments) endpoint to get an email's attachments.

> [!NOTE]
>
> This endpoint only returns emails sent by your team. If you need to list
> emails received by your domain, use the [List Received
> Emails](/docs/api-reference/emails/list-received-emails) endpoint.

## Query Parameters

**limit** `number`

Number of emails to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more emails (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more emails (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"
resend.Emails.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

emails = Resend::Emails.list
puts emails
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	paginatedResp, err := client.Emails.ListWithOptions(ctx, nil)
	if err != nil {
		panic(err)
	}

	if paginatedResp.HasMore {
		opts := &resend.ListOptions{
			After: &paginatedResp.Data[len(paginatedResp.Data)-1].Id,
		}
		client.Emails.ListWithOptions(ctx, opts)
	}
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _emails = resend.emails.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.ListEmailsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListEmailsResponseSuccess emails = resend.emails().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailListAsync();
Console.WriteLine( "Count={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "message_id": "<111-222-333@email.example.com>",
      "to": ["delivered@resend.dev"],
      "from": "Acme <onboarding@resend.dev>",
      "created_at": "2026-04-03 22:13:42.674981+00",
      "subject": "Hello World",
      "bcc": null,
      "cc": null,
      "reply_to": null,
      "last_event": "delivered",
      "scheduled_at": null
    },
    {
      "id": "3a9f8c2b-1e5d-4f8a-9c7b-2d6e5f8a9c7b",
      "message_id": "<444-555-666@email.example.com>",
      "to": ["user@example.com"],
      "from": "Acme <onboarding@resend.dev>",
      "created_at": "2026-04-03 21:45:12.345678+00",
      "subject": "Welcome to Acme",
      "bcc": null,
      "cc": null,
      "reply_to": null,
      "last_event": "opened",
      "scheduled_at": null
    }
  ]
}
```


# List Attachments
Source: https://resend.com/docs/api-reference/emails/list-received-email-attachments

GET /emails/receiving/:email_id/attachments
Retrieve a list of attachments from a received email.

## Query Parameters

**limit** `number`

Number of attachments to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more attachments (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more attachments (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

## Path Parameters

**email\_id** `string` *required*

The Email ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.receiving.attachments.list({
  emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->receiving->attachments->list(
  emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

attachments = resend.Emails.Receiving.Attachments.list(
  email_id='4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

attachments = Resend::Emails::Receiving::Attachments.list(
  email_id: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Emails.Receiving.ListAttachmentsWithContext(
		context.TODO(),
		"4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _email = resend
    .receiving
    .list_attachments(
      "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.receiving.model.ListAttachmentsResponse;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    ListAttachmentsResponse response = resend.receiving().listAttachments(
      "4ef9a417-02e9-4d39-ad75-9611e0fcc33c"
    );
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ReceivedEmailAttachmentListAsync( new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ));
Console.WriteLine( "Nr Attachments={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/emails/receiving/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails receiving attachments 4ef9a417-02e9-4d39-ad75-9611e0fcc33c
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
      "filename": "avatar.png",
      "size": 4096,
      "content_type": "image/png",
      "content_disposition": "inline",
      "content_id": "img001",
      "download_url": "https://inbound-cdn.resend.com/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318?some-params=example&signature=sig-123",
      "expires_at": "2026-10-17T14:29:41.521Z"
    }
  ]
}
```


# List Received Emails
Source: https://resend.com/docs/api-reference/emails/list-received-emails

GET /emails/receiving
Retrieve a list of received emails for the authenticated user.

You can list all emails received by your team. The list returns references to individual emails. If needed, you can use the `id` of an email to retrieve the email HTML to plain text using the [Retrieve Received Email](/docs/api-reference/emails/retrieve-received-email) endpoint or the [Retrieve Received Attachment](/docs/api-reference/emails/retrieve-received-email-attachment) endpoint to get an email's attachments.

> [!NOTE]
>
> This endpoint only returns emails received by your team. If you need to list
> emails sent by your team, use the [List Sent
> Emails](/docs/api-reference/emails/list-emails) endpoint.

## Query Parameters

**limit** `number`

Number of emails to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more emails (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more emails (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.receiving.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->receiving->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Emails.Receiving.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Emails::Receiving.list()
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Emails.Receiving.ListWithContext(context.TODO())
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _email = resend.receiving.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.receiving.model.ListReceivedEmailsResponse;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    ListReceivedEmailsResponse response = resend.receiving().list();
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ReceivedEmailListAsync();
Console.WriteLine( "Nr Received={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/emails/receiving' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails receiving list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": true,
  "data": [
    {
      "id": "a39999a6-88e3-48b1-888b-beaabcde1b33",
      "to": ["recipient@example.com"],
      "from": "sender@example.com",
      "created_at": "2026-10-09T14:37:40.951Z",
      "subject": "Hello World",
      "bcc": [],
      "cc": [],
      "reply_to": [],
      "message_id": "<111-222-333@email.example.com>",
      "attachments": [
        {
          "filename": "example.txt",
          "content_type": "text/plain",
          "content_id": null,
          "content_disposition": "attachment",
          "id": "47e999c7-c89c-4999-bf32-aaaaa1c3ff21",
          "size": 13
        }
      ]
    }
  ]
}
```


# Retrieve Sent Email
Source: https://resend.com/docs/api-reference/emails/retrieve-email

GET /emails/:email_id
Retrieve a single sent email.

## Path Parameters

**id** `string` *required*

The Email ID.

> [!NOTE]
>
> See all available `last_event` types in [the Email Events
> overview](/docs/dashboard/emails/manage-emails#understand-email-events).

```js Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.get(
  '37e4414c-5e25-4dbc-a071-43552a4bd53b',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->get('37e4414c-5e25-4dbc-a071-43552a4bd53b');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"
resend.Emails.get(email_id="4ef9a417-02e9-4d39-ad75-9611e0fcc33c")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

email = Resend::Emails.get("4ef9a417-02e9-4d39-ad75-9611e0fcc33c")
puts email
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Emails.Get("4ef9a417-02e9-4d39-ad75-9611e0fcc33c")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _email = resend
    .emails
    .get("4ef9a417-02e9-4d39-ad75-9611e0fcc33c")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.Email;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Email email = resend.emails().get("4ef9a417-02e9-4d39-ad75-9611e0fcc33c");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailRetrieveAsync( new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ) );
Console.WriteLine( "Subject={0}", resp.Content.Subject );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/emails/4ef9a417-02e9-4d39-ad75-9611e0fcc33c' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails get 4ef9a417-02e9-4d39-ad75-9611e0fcc33c
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "email",
  "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
  "message_id": "<111-222-333@email.example.com>",
  "to": ["delivered@resend.dev"],
  "from": "Acme <onboarding@resend.dev>",
  "created_at": "2026-04-03 22:13:42.674981+00",
  "subject": "Hello World",
  "html": "Congrats on sending your <strong>first email</strong>!",
  "text": null,
  "bcc": [],
  "cc": [],
  "reply_to": [],
  "last_event": "delivered",
  "scheduled_at": null,
  "tags": [
    {
      "name": "category",
      "value": "confirm_email"
    }
  ]
}
```


# Retrieve Attachment
Source: https://resend.com/docs/api-reference/emails/retrieve-email-attachment

GET /emails/:email_id/attachments/:attachment_id
Retrieve a single attachment from a sent email.

## Path Parameters

**id** `string` *required*

The Attachment ID.

**email\_id** `string` *required*

The Email ID.

```js Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.attachments.get({
  id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
  emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->attachments->get(
  id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
  emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

attachment = resend.Emails.Attachments.get(
  email_id='4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
  attachment_id='2a0c9ce0-3112-4728-976e-47ddcd16a318'
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

Resend::Emails::Attachments.get(
  id: "2a0c9ce0-3112-4728-976e-47ddcd16a318",
  email_id: "4ef9a417-02e9-4d39-ad75-9611e0fcc33c"
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Emails.GetAttachmentWithContext(
		context.TODO(),
		"4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
		"2a0c9ce0-3112-4728-976e-47ddcd16a318",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _email = resend
    .emails
    .get_attachment(
      "2a0c9ce0-3112-4728-976e-47ddcd16a318",
      "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.AttachmentResponse;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    AttachmentResponse attachment = resend.emails().getAttachment(
      "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "2a0c9ce0-3112-4728-976e-47ddcd16a318"
    );
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailAttachmentRetrieveAsync(
  emailId: new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ),
  attachmentId: new Guid( "2a0c9ce0-3112-4728-976e-47ddcd16a318" )
);
Console.WriteLine( "URL={0}", resp.Content.DownloadUrl );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/emails/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails attachment 4ef9a417-02e9-4d39-ad75-9611e0fcc33c 2a0c9ce0-3112-4728-976e-47ddcd16a318
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "attachment",
  "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
  "filename": "avatar.png",
  "size": 4096,
  "content_type": "image/png",
  "content_disposition": "inline",
  "content_id": "img001",
  "download_url": "https://outbound-cdn.resend.com/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318?some-params=example&signature=sig-123",
  "expires_at": "2026-10-17T14:29:41.521Z"
}
```


# Retrieve Received Email
Source: https://resend.com/docs/api-reference/emails/retrieve-received-email

GET /emails/receiving/:email_id
Retrieve a single received email.

## Path Parameters

**id** `string` *required*

The ID for the received email.

## Query Parameters

**html\_format** `'data_uri' | 'cid'`

Controls how inline images are returned inside `html`. The response echoes
the form actually served as `html_format` on the body.

By default (or when set to `data_uri`), inline images appear in `html` as base64 `data:` URIs. Set `html_format=cid` to keep the original `<img src="cid:..." />` references instead. Each `cid:` matches the `content_id` of an attachment, so you can correlate inline images with entries in the `attachments` array and fetch them via the attachment download endpoint.

Emails whose inlined HTML would exceed 100 MB, typically long reply chains that quote the same inline image hundreds of times, are always stored and returned with `cid:` references. For those emails the response reports `html_format: "cid"` regardless of the requested format, so check the `html_format` field on the body rather than assuming the format you asked for.

## Response Fields

**html\_format** `'data_uri' | 'cid'`

How inline images are referenced in `html`. Usually matches the requested
format, but is `cid` when the email is too large to inline (see the query
parameter above).

**received\_for** `array`

The recipient addresses the email was forwarded for, taken from the `for`
clause of the message's `Received` headers.

**authentication** `object | null`

The SPF, DKIM, and DMARC results computed when the email was received. These
come from the receiving mail server, not from the message headers, so the
sender cannot forge them. `null` for emails received before this field was
introduced.

**properties**

**spf** `'pass' | 'fail' | 'gray' | 'processing_failed' | 'unknown'`

SPF result. `gray` means the result was `none`, `softfail`, or `neutral`.

**dkim** `'pass' | 'fail' | 'gray' | 'processing_failed' | 'unknown'`

DKIM result. `gray` means the message is not signed, or the signing
domain does not match the `From` domain.

**dmarc** `'pass' | 'fail' | 'gray' | 'processing_failed' | 'unknown'`

DMARC result. `gray` means SPF or DKIM passed but the sending domain has
no DMARC policy or uses `p=none`.

**raw** `object | null`

Raw email content download information. Contains a signed URL to download the original email file including all attachments.

**properties**

**download\_url** `string`

Signed CloudFront URL to download the raw email file.

**expires\_at** `string`

ISO 8601 timestamp indicating when the download URL expires.

```js Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.receiving.get(
  '37e4414c-5e25-4dbc-a071-43552a4bd53b',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->receiving->get('37e4414c-5e25-4dbc-a071-43552a4bd53b');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Emails.Receiving.get(email_id="37e4414c-5e25-4dbc-a071-43552a4bd53b")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Emails::Receiving.get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Emails.Receiving.GetWithContext(
		context.TODO(),
		"37e4414c-5e25-4dbc-a071-43552a4bd53b",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::GetInboundEmailOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _email = resend
    .receiving
    .get(
      "37e4414c-5e25-4dbc-a071-43552a4bd53b",
      GetInboundEmailOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.receiving.model.ReceivedEmail;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    ReceivedEmail email = resend.receiving().get("37e4414c-5e25-4dbc-a071-43552a4bd53b");
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ReceivedEmailRetrieveAsync( new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ) );
Console.WriteLine( "Subject={0}", resp.Content.Subject );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/emails/receiving/4ef9a417-02e9-4d39-ad75-9611e0fcc33c' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails receiving get 4ef9a417-02e9-4d39-ad75-9611e0fcc33c
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "email",
  "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
  "to": ["delivered@resend.dev"],
  "from": "onboarding@resend.dev",
  "created_at": "2026-04-03T22:13:42.674Z",
  "subject": "Hello World",
  "html": "Congrats on sending your <strong>first email</strong>!",
  "html_format": "data_uri",
  "text": null,
  "headers": {
    "from": "Acme <onboarding@resend.dev>",
    "return-path": "lucas.costa@resend.com",
    "mime-version": "1.0"
  },
  "bcc": [],
  "cc": [],
  "reply_to": [],
  "received_for": ["forwarded@example.com"],
  "authentication": {
    "spf": "pass",
    "dkim": "pass",
    "dmarc": "pass"
  },
  "message_id": "<111-222-333@email.example.com>",
  "raw": {
    "download_url": "https://example.resend.com/receiving/raw/054da427-439a-4e91-b785-e4fb1966285f?Signature=...",
    "expires_at": "2026-04-03T23:13:42.674Z"
  },
  "attachments": [
    {
      "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
      "filename": "avatar.png",
      "content_type": "image/png",
      "content_disposition": "inline",
      "content_id": "img001",
      "size": 4096
    },
    {
      "id": "3b1d0df1-4223-5839-087f-54eedd27b419",
      "filename": "document.pdf",
      "content_type": "application/pdf",
      "content_disposition": null,
      "content_id": null,
      "size": 13264
    }
  ]
}
```


# Retrieve Attachment
Source: https://resend.com/docs/api-reference/emails/retrieve-received-email-attachment

GET /emails/receiving/:email_id/attachments/:attachment_id
Retrieve a single attachment from a received email.

## Path Parameters

**id** `string` *required*

The Attachment ID.

**email\_id** `string` *required*

The Email ID.

```js Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.receiving.attachments.get({
  id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
  emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->receiving->attachments->get(
  id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
  emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

attachment = resend.Emails.Receiving.Attachments.get(
  email_id='4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
  attachment_id='2a0c9ce0-3112-4728-976e-47ddcd16a318'
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

attachment = Resend::Emails::Receiving::Attachments.get(
  id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
  email_id: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Emails.Receiving.GetAttachmentWithContext(
		context.TODO(),
		"4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
		"2a0c9ce0-3112-4728-976e-47ddcd16a318",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _email = resend
    .receiving
    .get_attachment(
      "2a0c9ce0-3112-4728-976e-47ddcd16a318",
      "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.receiving.model.AttachmentDetails;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    AttachmentDetails attachment = resend.receiving().getAttachment(
      "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "2a0c9ce0-3112-4728-976e-47ddcd16a318"
    );
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ReceivedEmailAttachmentRetrieveAsync(
  emailId: new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ),
  attachmentId: new Guid( "2a0c9ce0-3112-4728-976e-47ddcd16a318" )
);
Console.WriteLine( "URL={0}", resp.Content.DownloadUrl );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/emails/receiving/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails receiving attachment 4ef9a417-02e9-4d39-ad75-9611e0fcc33c 2a0c9ce0-3112-4728-976e-47ddcd16a318
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "attachment",
  "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
  "filename": "avatar.png",
  "size": 4096,
  "content_type": "image/png",
  "content_disposition": "inline",
  "content_id": "img001",
  "download_url": "https://inbound-cdn.resend.com/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318?some-params=example&signature=sig-123",
  "expires_at": "2026-10-17T14:29:41.521Z"
}
```


# Send Batch Emails
Source: https://resend.com/docs/api-reference/emails/send-batch-emails

POST /emails/batch
Trigger up to 100 batch emails at once.

Instead of sending one email per HTTP request, Resend provides a batching endpoint that permits you to send up to 100 emails in a single API call.

## Body Parameters

**from** `string` *required*

Sender email address.

To include a friendly name, pass the sender as `Name <email@example.com>`, for example `Acme <onboarding@example.dev>`.

**to** `string | string[]` *required*

Recipient email address. For multiple addresses, send as an array of strings.
Max 50.

**subject** `string` *required*

Email subject.

**bcc** `string | string[]`

Bcc recipient email address. For multiple addresses, send as an array of
strings.

**cc** `string | string[]`

Cc recipient email address. For multiple addresses, send as an array of
strings.

Schedule email to be sent later. The date should be in natural language (e.g.: `in 1 min`) or ISO 8601 format (e.g:
`2026-08-05T11:52:01.858Z`).

[See examples](/docs/dashboard/emails/schedule-email)

Reply-to email address. For multiple addresses, send as an array of strings.

**html** `string`

The HTML version of the message.

**text** `string`

The plain text version of the message.

> [!NOTE]
>
> If not provided, the HTML will be used to generate a plain text version. You
> can opt out of this behavior by setting value to an empty string.

**react** `React.ReactNode`

The React component used to write the message. *Only available in the Node.js
SDK.*

**headers** `object`

Custom headers to add to the email.

The topic ID to receive the email.

* If the recipient is a contact and has opted-in to the topic, the email is sent.
* If the recipient is a contact and has opted-out of the topic, the email is not sent and will be marked as failed.
* If the recipient is not a contact, the email is sent if the topic default subscription value is set to `opt-in`.

> [!NOTE]
>
> Each email address (to, cc, bcc) is checked and handled separately.

**tags** `array`

Custom data passed in key/value pairs.

[See examples](/docs/dashboard/emails/tags).

**properties**

**name** `string` *required*

The name of the email tag.

It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (\_), or dashes (-).

It can contain no more than 256 characters.

**value** `string` *required*

The value of the email tag.

It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (\_), or dashes (-).

It can contain no more than 256 characters.

**template** `object`

To send using a template, provide a `template` object with:

* `id`: the id *or* the alias of the published template
* `variables`: an object with a key for each variable (if applicable)

> [!NOTE]
>
> If a `template` is provided, you cannot send `html`, `text`, or `react` in the payload, otherwise the API will return a validation error.
>
> When sending a template, the payload for `from`, `subject`, and `reply_to` take precedence over the template's defaults for these fields. If the template does not provide a default value for these fields, you must provide them in the payload.

**id** `string` *required*

The id of the published email template. Required if `template` is provided. Only published templates can be used when sending emails.

**variables** `object`

Template variables object with key/value pairs.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
variables: {
	CTA: 'Sign up now',
	CTA_LINK: 'https://example.com/signup'
}
```

When sending the template, the HTML will be parsed. If all the variables used in the template were provided, the email will be sent. If not, the call will throw a validation error.

See the [errors reference](/docs/api-reference/errors) for more details or [learn more about templates](/docs/dashboard/templates/introduction).

**properties**

**key** `string` *required*

The key of the variable.

May only contain ASCII letters (a–z, A–Z), numbers (0–9), and underscores (\_). The following variable names are reserved and cannot be used: `FIRST_NAME`, `LAST_NAME`, `EMAIL`, `UNSUBSCRIBE_URL`.

It can contain no more than 50 characters.

**value** `string | number` *required*

The value of the variable.

Observe these technical limitations:

* `string`: maximum length of 2,000 characters
* `number`: not greater than 2^53 - 1

## Headers

**Idempotency-Key** `string`

Add an idempotency key to prevent duplicated emails.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**

[Learn more about idempotency keys →](/docs/dashboard/emails/idempotency-keys)

## Limitations

The `attachments` field is not supported yet.

## Response format

When the request succeeds, each entry in `data` corresponds to the email at the same index in the batch payload (0-based). The first email in your request will be the first entry in `data`, and so on.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.batch.send([
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['foo@gmail.com'],
    subject: 'hello world',
    html: '<h1>it works!</h1>',
  },
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['bar@outlook.com'],
    subject: 'world hello',
    html: '<p>it works!</p>',
  },
]);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->batch->send([
  [
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['foo@gmail.com'],
    'subject' => 'hello world',
    'html' => '<h1>it works!</h1>',
  ],
  [
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['bar@outlook.com'],
    'subject' => 'world hello',
    'html' => '<p>it works!</p>',
  ]
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend
from typing import List

resend.api_key = "re_xxxxxxxxx"

params: List[resend.Emails.SendParams] = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
  }
]

resend.Batch.send(params)
```

```rb Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = 're_xxxxxxxxx'

params = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
  }
]

Resend::Batch.send(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {

  ctx := context.TODO()

  client := resend.NewClient("re_xxxxxxxxx")

  var batchEmails = []*resend.SendEmailRequest{
    {
      From:    "Acme <onboarding@resend.dev>",
      To:      []string{"foo@gmail.com"},
      Subject: "hello world",
      Html:    "<h1>it works!</h1>",
    },
    {
      From:    "Acme <onboarding@resend.dev>",
      To:      []string{"bar@outlook.com"},
      Subject: "world hello",
      Html:    "<p>it works!</p>",
    },
  }

  sent, err := client.Batch.SendWithContext(ctx, batchEmails)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Data)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let emails = vec![
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["foo@gmail.com"],
      "hello world",
    )
    .with_html("<h1>it works!</h1>"),
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["bar@outlook.com"],
      "world hello",
    )
    .with_html("<p>it works!</p>"),
  ];

  let _emails = resend.batch.send(emails).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.batch.model.CreateBatchEmailsResponse;
import com.resend.services.emails.model.CreateEmailOptions;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions firstEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("foo@gmail.com")
            .subject("hello world")
            .html("<h1>it works!</h1>")
            .build();

        CreateEmailOptions secondEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("bar@outlook.com")
            .subject("world hello")
            .html("<p>it works!</p>")
            .build();

        CreateBatchEmailsResponse data = resend.batch().send(
            Arrays.asList(firstEmail, secondEmail)
        );
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var mail1 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "foo@gmail.com",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
};

var mail2 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "bar@outlook.com",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
};

var resp = await resend.EmailBatchAsync( [ mail1, mail2 ] );
Console.WriteLine( "Nr Emails={0}", resp.Content.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails/batch' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'[
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>"
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>"
  }
]'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails batch --file ./path/to/emails.json
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "data": [
    {
      "id": "ae2014de-c168-4c61-8267-70d2662a1ce1"
    },
    {
      "id": "faccb7a5-8a28-4e9a-ac64-8da1cc3bc1cb"
    }
  ]
}
```


# Send Email
Source: https://resend.com/docs/api-reference/emails/send-email

POST /emails
Start sending emails through the Resend Email API.

## Body Parameters

**from** `string` *required*

Sender email address.

To include a friendly name, pass the sender as `Name <email@example.com>`, for example `Acme <onboarding@example.dev>`.

**to** `string | string[]` *required*

Recipient email address. For multiple addresses, send as an array of strings.
Max 50.

**subject** `string` *required*

Email subject.

**bcc** `string | string[]`

Bcc recipient email address. For multiple addresses, send as an array of
strings.

**cc** `string | string[]`

Cc recipient email address. For multiple addresses, send as an array of
strings.

Schedule email to be sent later. The date should be in natural language (e.g.: `in 1 min`) or ISO 8601 format (e.g:
`2026-08-05T11:52:01.858Z`).

[See examples](/docs/dashboard/emails/schedule-email)

Reply-to email address. For multiple addresses, send as an array of strings.

**html** `string`

The HTML version of the message.

**text** `string`

The plain text version of the message.

> [!NOTE]
>
> If not provided, the HTML will be used to generate a plain text version. You
> can opt out of this behavior by setting value to an empty string.

**react** `React.ReactNode`

The React component used to write the message. *Only available in the Node.js
SDK.*

**headers** `object`

Custom headers to add to the email.

The topic ID to receive the email.

* If the recipient is a contact and has opted-in to the topic, the email is sent.
* If the recipient is a contact and has opted-out of the topic, the email is not sent and will be marked as failed.
* If the recipient is not a contact, the email is sent if the topic default subscription value is set to `opt-in`.

> [!NOTE]
>
> Each email address (to, cc, bcc) is checked and handled separately.

**attachments** `array`

Filename and content of attachments (max 40MB per email, after Base64 encoding of the attachments).

[See examples](/docs/dashboard/emails/attachments)

**properties**

**content** `buffer | string`

Content of an attached file, passed as a buffer or Base64 string.

**filename** `string`

Name of attached file.

**path** `string`

Path where the attachment file is hosted

Content type for the attachment, if not set will be derived from the filename property

You can embed images using the content id parameter for the attachment. To show the image, you need to include the ID in the `src` attribute of the `img` tag (e.g., `<img src="cid:...">`) of your HTML. [Learn about inline images](/docs/dashboard/emails/embed-inline-images).

**tags** `array`

Custom data passed in key/value pairs.

[See examples](/docs/dashboard/emails/tags).

**properties**

**name** `string` *required*

The name of the email tag.

It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (\_), or dashes (-).

It can contain no more than 256 characters.

**value** `string` *required*

The value of the email tag.

It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (\_), or dashes (-).

It can contain no more than 256 characters.

**template** `object`

To send using a template, provide a `template` object with:

* `id`: the id *or* the alias of the published template
* `variables`: an object with a key for each variable (if applicable)

> [!NOTE]
>
> If a `template` is provided, you cannot send `html`, `text`, or `react` in the payload, otherwise the API will return a validation error.
>
> When sending a template, the payload for `from`, `subject`, and `reply_to` take precedence over the template's defaults for these fields. If the template does not provide a default value for these fields, you must provide them in the payload.

**id** `string` *required*

The id of the published email template. Required if `template` is provided. Only published templates can be used when sending emails.

**variables** `object`

Template variables object with key/value pairs.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
variables: {
	CTA: 'Sign up now',
	CTA_LINK: 'https://example.com/signup'
}
```

When sending the template, the HTML will be parsed. If all the variables used in the template were provided, the email will be sent. If not, the call will throw a validation error.

See the [errors reference](/docs/api-reference/errors) for more details or [learn more about templates](/docs/dashboard/templates/introduction).

**properties**

**key** `string` *required*

The key of the variable.

May only contain ASCII letters (a–z, A–Z), numbers (0–9), and underscores (\_). The following variable names are reserved and cannot be used: `FIRST_NAME`, `LAST_NAME`, `EMAIL`, `UNSUBSCRIBE_URL`.

It can contain no more than 50 characters.

**value** `string | number` *required*

The value of the variable.

Observe these technical limitations:

* `string`: maximum length of 2,000 characters
* `number`: not greater than 2^53 - 1

## Headers

**Idempotency-Key** `string`

Add an idempotency key to prevent duplicated emails.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**

[Learn more](/docs/dashboard/emails/idempotency-keys)

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'hello world',
  html: '<p>it works!</p>',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'html' => '<p>it works!</p>'
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>"
}

email = resend.Emails.send(params)
print(email)
```

```rb Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>"
}

sent = Resend::Emails.send(params)
puts sent
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.SendEmailRequest{
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Subject:     "hello world",
      Html:        "<p>it works!</p>",
  }

  sent, err := client.Emails.SendWithContext(ctx, params)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Id)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::{CreateEmailBaseOptions};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "hello world";
  let html = "<p>it works!</p>";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html(html);

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("hello world")
                .html("<p>it works!</p>")
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailSendAsync( new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
} );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "hello world" \
  --html "<p>it works!</p>"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
}
```


# Share Email
Source: https://resend.com/docs/api-reference/emails/share-email

POST /emails/:email_id/share
Create a shareable link to view a sent or received email.

## Path Parameters

The Email ID.

## Body Parameters

How long the link stays valid for, as a duration like `10m`, `2 hours`, or `1
    day`. Defaults to `48h` and cannot exceed 48 hours.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.share(
  '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794',
  { expiresIn: '2 hours' },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->share('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794', [
  'expires_in' => '2 hours'
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

share_params: resend.Emails.ShareParams = {
  "expires_in": "2 hours"
}

resend.Emails.share(
  email_id="49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  params=share_params
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Emails.share(
  "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  expires_in: "2 hours"
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	shareParams := &resend.ShareEmailRequest{
		ExpiresIn: "2 hours",
	}

	shared, err := client.Emails.Share("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", shareParams)
	if err != nil {
		panic(err)
	}
	fmt.Println(shared.Url)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::ShareEmailOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let share = ShareEmailOptions::new()
    .with_expires_in("2 hours");

  let _shared = resend
    .emails
    .share("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", share)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.ShareEmailOptions;
import com.resend.services.emails.model.ShareEmailResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ShareEmailOptions shareParams = ShareEmailOptions.builder()
                .expiresIn("2 hours")
                .build();

        ShareEmailResponse data = resend
          .emails()
          .share("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", shareParams);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.EmailShareAsync(
    new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ),
    "2 hours" );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794/share' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "expires_in": "2 hours"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails share 49a3999c-0ce1-4ea6-ab68-afcd6dc2e794 \
  --expires-in "2 hours"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "email",
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  "url": "https://resend.com/shared?token=eyJhbGciOiJIUzI1NiJ9..."
}
```


# Update Email
Source: https://resend.com/docs/api-reference/emails/update-email

PATCH /emails/:email_id
Update a scheduled email.

## Path Parameters

**id** `string` *required*

The Email ID.

## Body Parameters

Schedule email to be sent later. The date should be in ISO 8601 format (e.g:
2026-08-05T11:52:01.858Z).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const oneMinuteFromNow = new Date(Date.now() + 1000 * 60).toISOString();

const { data, error } = await resend.emails.update({
  id: '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794',
  scheduledAt: oneMinuteFromNow,
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$oneMinuteFromNow = (new DateTime())->modify('+1 minute')->format(DateTime::ISO8601);

$resend->emails->update('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794', [
  'scheduled_at' => $oneMinuteFromNow
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend
from datetime import datetime, timedelta

resend.api_key = "re_xxxxxxxxx"

one_minute_from_now = (datetime.now() + timedelta(minutes=1)).isoformat()

update_params: resend.Emails.UpdateParams = {
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  "scheduled_at": one_minute_from_now
}

resend.Emails.update(params=update_params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

one_minute_from_now = (Time.now + 1 * 60).strftime("%Y-%m-%dT%H:%M:%S.%L%z")

update_params = {
  "email_id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  "scheduled_at": one_minute_from_now
}

Resend::Emails.update(update_params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"time"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	oneMinuteFromNow := time.Now().Add(time.Minute * time.Duration(1))
	oneMinuteFromNowIso := oneMinuteFromNow.Format("2006-01-02T15:04:05-0700")

	updateParams := &resend.UpdateEmailRequest{
		Id:          "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
		ScheduledAt: oneMinuteFromNowIso,
	}

	client.Emails.Update(updateParams)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use chrono::{Local, TimeDelta};
use resend_rs::types::UpdateEmailOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let one_minute_from_now = Local::now()
    .checked_add_signed(TimeDelta::minutes(1))
    .unwrap()
    .to_rfc3339();

  let update = UpdateEmailOptions::new()
    .with_scheduled_at(&one_minute_from_now);

  let _email = resend
    .emails
    .update("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", update)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.UpdateEmailOptions;
import com.resend.services.emails.model.UpdateEmailResponse;
import java.time.Instant;
import java.time.temporal.ChronoUnit;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        String oneMinuteFromNow = Instant
          .now()
          .plus(1, ChronoUnit.MINUTES)
          .toString();

        UpdateEmailOptions updateParams = UpdateEmailOptions.builder()
                .scheduledAt(oneMinuteFromNow)
                .build();

        UpdateEmailResponse data = resend.emails().update("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", updateParams);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.EmailRescheduleAsync(
    new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ),
    DateTime.UtcNow.AddMinutes( 1 ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/emails/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "scheduled_at": "2026-08-05T11:52:01.858Z"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails update 49a3999c-0ce1-4ea6-ab68-afcd6dc2e794 \
  --scheduled-at "2026-08-05T11:52:01.858Z"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "email",
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
}
```


# Errors
Source: https://resend.com/docs/api-reference/errors

Troubleshoot problems with this comprehensive breakdown of all error codes.

## Error schema

Resend uses standard HTTP response codes for success and failure notifications, and errors are further classified by type.

### `invalid_idempotency_key`

* **Status:** 400
* **Message:** Idempotency keys, if present, must have between 1 and 256 characters.
* **Suggested action:** Retry with a valid idempotency key.

### `validation_error`

* **Status:** 400
* **Message:** An error was found with one or more fields in the request.
* **Suggested action:** The message will contain more details about what field and error were found.

### `validation_error`

* **Status:** 400
* **Message:** API key is invalid
* **Suggested action:** Check the key on the [API Keys page](https://resend.com/api-keys) and create a new one if it was deleted. Every endpoint except sending returns this for a key that doesn't exist or was deleted, and every endpoint returns it when the `Authorization` header isn't a valid key.

### `missing_api_key`

* **Status:** 401
* **Message:** Missing API Key
* **Suggested action:** Include the following header in the request: `Authorization: Bearer YOUR_API_KEY`.

### `restricted_api_key`

* **Status:** 401
* **Message:** This API key is restricted to only send emails.
* **Suggested action:** Make sure the API key has `Full access` to perform actions other than sending emails.

### `validation_error`

* **Status:** 401
* **Message:** API key is invalid
* **Suggested action:** Check the key on the [API Keys page](https://resend.com/api-keys) and create a new one if it was deleted. The sending endpoints return this for a key that doesn't exist, was deleted, or isn't active.

### `email_above_quota`

* **Status:** 403
* **Message:** You can't retrieve this email's content because it was above quota when received.
* **Suggested action:** [Upgrade your plan](https://resend.com/settings/billing) to increase your quota.

### `invalid_permission`

* **Status:** 403
* **Message:** Access token is missing required scopes.
* **Suggested action:** Request an access token that includes the scopes required by this endpoint.

### `restricted_api_key`

* **Status:** 403
* **Message:** API key is not active
* **Suggested action:** Check the API key on the [API Keys page](https://resend.com/api-keys) and create a new one if needed.

### `suspended_api_key`

* **Status:** 403
* **Message:** This API key is suspended
* **Suggested action:** [Contact support](https://resend.com/contact) if you believe this is a mistake.

### `validation_error`

* **Status:** 403
* **Message:** You can only send testing emails to your own email address (`youremail@domain.com`). To send emails to other recipients, please verify a domain at resend.com/domains, and change the `from` address to an email using this domain.
* **Suggested action:** In [Resend's Domain page](https://resend.com/domains), add and verify a domain for which you have DNS access. This allows you to send emails to addresses beyond your own. [Learn more about resolving this error](/docs/knowledge-base/403-error-resend-dev-domain).

### `validation_error`

* **Status:** 403
* **Message:** The `domain.com` domain is not verified. Please, add and verify your domain.
* **Suggested action:** Make sure the domain in your API request's `from` field matches a domain you've verified in Resend. Update your API request to use your verified domain, or add and verify the domain you're trying to use. [Learn more about resolving this error](/docs/knowledge-base/403-error-domain-mismatch).

### `validation_error`

* **Status:** 403
* **Message:** The `example.com` domain has been registered already.
* **Suggested action:** Verify you are signed in to the correct Resend account and check whether a teammate already added the domain. If you still cannot access it, [contact support](https://resend.com/help). [Learn more about resolving this error](/docs/knowledge-base/domain-already-registered).

### `validation_error`

* **Status:** 403
* **Message:** You have reached the inboxes included in your plan. Enable pay-as-you-go for inboxes at [https://resend.com/settings/usage](https://resend.com/settings/usage) to add more.
* **Suggested action:** Every plan includes 3 inboxes. A team admin can enable pay-as-you-go for inboxes in your [usage settings](https://resend.com/settings/usage), after which each extra inbox costs \$1 per month.

### `validation_error`

* **Status:** 403
* **Message:** You have reached the inboxes included in your plan. Upgrade your Transactional plan to unlock pay-as-you-go for inboxes.
* **Suggested action:** Every plan includes 3 inboxes, and pay-as-you-go for inboxes needs a paid Transactional plan. [Upgrade your plan](https://resend.com/settings/billing), then enable pay-as-you-go for inboxes in your [usage settings](https://resend.com/settings/usage).

### `validation_error`

* **Status:** 403
* **Message:** You have reached the inboxes included in your plan. Pay-as-you-go for inboxes isn't available for your billing setup.
* **Suggested action:** Teams billed through Vercel or Stripe Projects cannot enable pay-as-you-go for inboxes. [Contact support](https://resend.com/help) if you need more than the 3 included inboxes.

### `validation_error`

* **Status:** 403
* **Message:** You have reached the inboxes included in your plan. Manage pay-as-you-go for inboxes at [https://resend.com/settings/usage](https://resend.com/settings/usage) to add more.
* **Suggested action:** Every plan includes 3 inboxes. Open your [usage settings](https://resend.com/settings/usage) to enable pay-as-you-go for inboxes, which needs a paid Transactional plan.

### `not_found`

* **Status:** 404
* **Message:** The requested endpoint does not exist.
* **Suggested action:** Change your request URL to match a valid API endpoint.

### `method_not_allowed`

* **Status:** 405
* **Message:** Method is not allowed for the requested path.
* **Suggested action:** Change your API endpoint to use a valid method.

### `concurrent_idempotent_requests`

* **Status:** 409
* **Message:** There is another request in progress with the same idempotency key.
* **Suggested action:** Try the request again later.

### `invalid_idempotent_request`

* **Status:** 409
* **Message:** This idempotency key has been used with this HTTP method and endpoint within the last 24 hours, but the request body was modified and doesn't match the original request.
* **Suggested action:** Change your idempotency key or payload.

### `resource_locked`

* **Status:** 409
* **Message:** Another request is already updating this resource.
* **Suggested action:** Retry the request after a short delay.

### `invalid_attachment`

* **Status:** 422
* **Message:** Attachment must have either a `content` or `path`.
* **Suggested action:** Attachments must either have a `content` (strings, Buffer, or Stream contents) or `path` to a remote resource (better for larger attachments).

### `invalid_parameter`

* **Status:** 422
* **Message:** The `parameter` must be a valid UUID.
* **Suggested action:** Check the value and make sure it's valid.

### `missing_required_field`

* **Status:** 422
* **Message:** The request body is missing one or more required fields.
* **Suggested action:** Check the error message to see the list of missing fields.

### `missing_required_parameter`

* **Status:** 422
* **Message:** The request is missing one or more required parameters.
* **Suggested action:** Check the error message to see the list of missing parameters.

### `daily_quota_exceeded`

* **Status:** 429
* **Message:** You have exceeded your daily email sending quota.
* **Suggested action:** [Upgrade your plan](https://resend.com/settings/billing) to remove the daily quota limit or wait for the quota to reset at midnight UTC. Both sent and received emails count towards this quota.

### `monthly_quota_exceeded`

* **Status:** 429
* **Message:** You have exceeded your monthly email sending quota.
* **Suggested action:** [Upgrade your plan](https://resend.com/settings/billing) to increase the monthly email quota. Both sent and received emails count towards this quota.

### `rate_limit_exceeded`

* **Status:** 429
* **Message:** Too many requests. Please limit the number of requests per second. Or [contact support](https://resend.com/contact) to increase rate limit.
* **Suggested action:** Read the [response headers](/docs/api-reference/introduction#rate-limit) and reduce the rate at which you request the API. This can be done by introducing a queue mechanism or reducing the number of concurrent requests per second. If you have specific requirements, [contact support](https://resend.com/contact) to request a rate increase.

### `application_error`

* **Status:** 500
* **Message:** An unexpected error occurred.
* **Suggested action:** Try the request again later. If the error does not resolve, check our [status page](https://resend-status.com) for service updates.

### `service_unavailable`

* **Status:** 503
* **Message:** API is temporarily unavailable
* **Suggested action:** Try the request again later. Check our [status page](https://resend-status.com) for service updates.


# Create Event
Source: https://resend.com/docs/api-reference/events/create-event

POST /events
Create a new event that can be used to trigger automations.

## Body Parameters

**name** `string` *required*

The name of the event. Used to match events to automation triggers.

> [!NOTE]
>
> The event name can be any string (e.g., `user.created`, `welcome`,
> `my-custom-event`). Dot notation is a recommended convention but is not
> required. If multiple enabled automations use the same event name, all of them
> will be triggered. Use unique event names if you want to target a specific
> automation.

> [!WARNING]
>
> Event names cannot start with the `resend:` prefix, which is reserved for system events.

**schema** `object`

An optional schema definition for the event payload. Must be an object with
flat key/type pairs. Supported types: `string`, `number`, `boolean`, `date`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.events.create({
  name: 'user.created',
  schema: {
    plan: 'string',
  },
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->events->create([
  'name' => 'user.created',
  'schema' => ['plan' => 'string'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Events.CreateParams = {
  "name": "user.created",
  "schema": {
    "plan": "string",
  },
}

resend.Events.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "user.created",
  schema: {
    plan: "string",
  },
}

Resend::Events.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateEventRequest{
		Name: "user.created",
		Schema: map[string]string{
			"plan": resend.EventSchemaTypeString,
		},
	}

	client.Events.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{json, types::CreateEventOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = CreateEventOptions {
    name: "user.created".to_owned(),
    schema: json!({
      "plan": "string",
    }),
  };

  let _event = resend.events.create(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.CreateEventOptions;
import com.resend.services.events.model.CreateEventResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEventOptions params = CreateEventOptions.builder()
                .name("user.created")
                .addSchema("plan", "string")
                .build();

        CreateEventResponseSuccess data = resend.events().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var schema = JsonSerializer.SerializeToElement( new { plan = "string" } );

var resp = await resend.EventCreateAsync( new EventCreateData()
{
    Name = "user.created",
    Schema = schema,
} );
Console.WriteLine( "EventId={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/events' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "name": "user.created",
  "schema": {
    "plan": "string"
  }
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend events create --name user.created --schema '{"plan":"string"}'
```

> [!NOTE]
>
> Successful creation returns **201 Created** with the JSON body below.

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "event",
  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
}
```


# Delete Event
Source: https://resend.com/docs/api-reference/events/delete-event

DELETE /events/:id
Remove an existing event.

## Path Parameters

The event ID or name.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.events.remove('user.created');
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->events->remove('user.created');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Events.remove("user.created")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Events.remove("user.created")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Events.Remove("user.created")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _event = resend.events.delete("user.created").await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.RemoveEventResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveEventResponseSuccess data = resend.events().remove("user.created");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.EventDeleteAsync( "user.created" );
Console.WriteLine( "Deleted={0}", resp.Content.Deleted );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/events/user.created' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend events delete user.created
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "event",
  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "deleted": true
}
```


# Retrieve Event
Source: https://resend.com/docs/api-reference/events/get-event

GET /events/:id
Retrieve a single event by ID or name.

## Path Parameters

The event ID or name.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.events.get('user.created');
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->events->get('user.created');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Events.get("user.created")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Events.get("user.created")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Events.Get("user.created")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _event = resend.events.get("user.created").await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.Event;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Event event = resend.events().get("user.created");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.EventRetrieveAsync( "user.created" );
Console.WriteLine( "Name={0}", resp.Content.Name );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/events/user.created' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend events get user.created
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "event",
  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "name": "user.created",
  "schema": {
    "plan": "string"
  },
  "created_at": "2026-10-01 12:00:00.000000+00",
  "updated_at": "2026-10-01 12:00:00.000000+00"
}
```


# List Events
Source: https://resend.com/docs/api-reference/events/list-events

GET /events
Retrieve a list of events.

## Query Parameters

**limit** `number`

Number of events to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more events (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more events (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.events.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->events->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Events.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Events.list
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Events.List()
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _events = resend.events.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.ListEventsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListEventsResponseSuccess data = resend.events().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.EventListAsync();
Console.WriteLine( "Count={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/events' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend events list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "name": "user.created",
      "schema": {
        "plan": "string"
      },
      "created_at": "2026-10-01 12:00:00.000000+00",
      "updated_at": "2026-10-01 12:00:00.000000+00"
    },
    {
      "id": "b2c3d4e5-f6a7-8901-bcde-f12345678901",
      "name": "user.upgraded",
      "schema": null,
      "created_at": "2026-09-15 08:30:00.000000+00",
      "updated_at": "2026-09-20 14:00:00.000000+00"
    }
  ]
}
```


# Send Event
Source: https://resend.com/docs/api-reference/events/send-event

POST /events/send
Send a named event to trigger matching automations.

## Body Parameters

**event** `string` *required*

The name of the event to trigger. Must match the event name configured in an
automation trigger step.

Either `contact_id` or `email` must be provided, but not both.

The contact ID (UUID) to associate with this event. Exactly one of
`contact_id` or `email` must be provided.

**email** `string`

The email address to associate with this event. Exactly one of `contact_id` or
`email` must be provided. If no contact with this email exists in your
Audience, one will be created automatically when the automation runs.

**payload** `object`

An optional object containing custom data to pass to the automation. This data
can be used in template variables and conditions. If the event has a schema
defined, the payload values will be validated and coerced to match the schema
types.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.events.send({
  event: 'user.created',
  contactId: '7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b',
  // or: email: 'steve.wozniak@gmail.com',
  payload: {
    plan: 'pro',
  },
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Trigger with a contact ID
$resend->events->send([
  'event' => 'user.created',
  'contact_id' => '7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b',
  'payload' => ['plan' => 'pro'],
]);

// Trigger with an email address
$resend->events->send([
  'event' => 'user.created',
  'email' => 'steve.wozniak@gmail.com',
  'payload' => ['plan' => 'pro'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Trigger with a contact ID
params: resend.Events.SendParams = {
  "event": "user.created",
  "contact_id": "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
  "payload": {
    "plan": "pro",
  },
}

resend.Events.send(params)

# Trigger with an email address
params: resend.Events.SendParams = {
  "event": "user.created",
  "email": "steve.wozniak@gmail.com",
  "payload": {
    "plan": "pro",
  },
}

resend.Events.send(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Trigger with a contact ID
params = {
  event: "user.created",
  contact_id: "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
  payload: {
    plan: "pro",
  },
}

Resend::Events.send(params)

# Trigger with an email address
params = {
  event: "user.created",
  email: "steve.wozniak@gmail.com",
  payload: {
    plan: "pro",
  },
}

Resend::Events.send(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Trigger with a contact ID
	params := &resend.SendEventRequest{
		Event:     "user.created",
		ContactId: "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
		Payload: map[string]any{
			"plan": "pro",
		},
	}

	client.Events.Send(params)

	// Trigger with an email address
	params = &resend.SendEventRequest{
		Event: "user.created",
		Email: "steve.wozniak@gmail.com",
		Payload: map[string]any{
			"plan": "pro",
		},
	}

	client.Events.Send(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  json,
  types::{ContactIdOrEmail, SendEventOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = SendEventOptions {
    event: "user.created".to_owned(),
    contact_id_or_email: ContactIdOrEmail::ContactId(
      "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b".to_owned(),
    ),
    // or: ContactIdOrEmail::Email("steve.wozniak@gmail.com".to_owned())
    payload: json!({
      "plan": "pro"
    }),
  };

  let _event = resend.events.send(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.SendEventOptions;
import com.resend.services.events.model.SendEventResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        SendEventOptions params = SendEventOptions.builder()
                .event("user.created")
                .contactId("7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b") // or: .email("steve.wozniak@gmail.com")
                .addPayload("plan", "pro")
                .build();

        SendEventResponseSuccess data = resend.events().send(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var payload = JsonSerializer.SerializeToElement( new { plan = "pro" } );

// Trigger with a contact ID
var resp = await resend.EventSendAsync( new EventSendData()
{
    Event = "user.created",
    ContactId = new Guid( "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b" ),
    Payload = payload,
} );
Console.WriteLine( "Event={0}", resp.Content.Event );

// Trigger with an email address
await resend.EventSendAsync( new EventSendData()
{
    Event = "user.created",
    Email = "steve.wozniak@gmail.com",
    Payload = payload,
} );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Trigger with a contact ID
curl -X POST 'https://api.resend.com/events/send' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "event": "user.created",
  "contact_id": "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
  "payload": {
    "plan": "pro"
  }
}'

# Trigger with an email address
curl -X POST 'https://api.resend.com/events/send' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "event": "user.created",
  "email": "steve.wozniak@gmail.com",
  "payload": {
    "plan": "pro"
  }
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Trigger with a contact ID
resend events send \
  --event user.created \
  --contact-id 7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b \
  --payload '{"plan":"pro"}'

# Trigger with an email address
resend events send \
  --event user.created \
  --email steve.wozniak@gmail.com \
  --payload '{"plan":"pro"}'
```

> [!NOTE]
>
> Successful requests return **202 Accepted** with the JSON body below.

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "event",
  "event": "user.created"
}
```


# Update Event
Source: https://resend.com/docs/api-reference/events/update-event

PATCH /events/:id
Update an existing event schema.

## Path Parameters

The event ID or name.

## Body Parameters

**schema** `object` *required*

The updated schema definition for the event payload. Must be an object with
flat key/type pairs, or `null` to clear the schema. Supported types: `string`,
`number`, `boolean`, `date`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.events.update('user.created', {
  schema: {
    plan: 'string',
    trial: 'boolean',
  },
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->events->update('user.created', [
  'schema' => [
    'plan' => 'string',
    'trial' => 'boolean',
  ],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Events.UpdateParams = {
  "identifier": "user.created",
  "schema": {
    "plan": "string",
    "trial": "boolean",
  },
}

resend.Events.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  identifier: "user.created",
  schema: {
    plan: "string",
    trial: "boolean",
  },
}

Resend::Events.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.UpdateEventRequest{
		Schema: map[string]string{
			"plan":  resend.EventSchemaTypeString,
			"trial": resend.EventSchemaTypeBoolean,
		},
	}

	client.Events.Update("user.created", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{json, types::UpdateEventOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = UpdateEventOptions {
    schema: json!({
      "plan": "string",
      "trial": "boolean",
    }),
  };

  let _event = resend.events.update("user.created", opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.UpdateEventOptions;
import com.resend.services.events.model.UpdateEventResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateEventOptions params = UpdateEventOptions.builder()
                .identifier("user.created")
                .addSchema("plan", "string")
                .addSchema("trial", "boolean")
                .build();

        UpdateEventResponseSuccess data = resend.events().update(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var schema = JsonSerializer.SerializeToElement( new { plan = "string", trial = "boolean" } );

var resp = await resend.EventUpdateAsync( "user.created", new EventUpdateData { Schema = schema } );
Console.WriteLine( "EventId={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/events/user.created' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "schema": {
    "plan": "string",
    "trial": "boolean"
  }
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend events update user.created --schema '{"plan":"string","trial":"boolean"}'
```

> [!NOTE]
>
> Successful updates return **200 OK** with the JSON body below.

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "event",
  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
}
```


# Add Thread Labels
Source: https://resend.com/docs/api-reference/inboxes/add-thread-labels

POST /inboxes/:inbox_id/threads/:thread_id/labels
Apply one or more labels to a thread.

Labels already on the thread stay on it. If any label ID is not found, the
request returns a `404` and nothing changes. To replace the thread's labels
instead, use [Set Thread Labels](/docs/api-reference/inboxes/set-thread-labels).

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

## Body Parameters

**labels** `string[]` *required*

The IDs of the labels to apply. Between 1 and 10 IDs, each belonging to the
inbox.

## Response Fields

**object** `string`

Always `list`.

**data** `array`

Every label on the thread after the change.

**properties**

**id** `string`

The ID of the label.

**name** `string`

The name of the label.

**color** `string`

The color of the label as an uppercase `#RRGGBB` hex code, like
`#E93D82`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.labels.add({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  labels: ['7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34'],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->labels->add(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  [
    'labels' => ['7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34'],
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.Labels.AddParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    "labels": ["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"],
}

resend.Inboxes.Threads.Labels.add(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  labels: ["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"]
}

Resend::Inboxes::Threads::Labels.add(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.AddInboxThreadLabelsRequest{
		Labels: []string{"7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"},
	}

	client.Inboxes.Threads.Labels.Add(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _labels = resend
    .inboxes
    .add_thread_labels(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      &["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"],
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.AddInboxThreadLabelsOptions;
import com.resend.services.inboxes.model.AddInboxThreadLabelsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        AddInboxThreadLabelsOptions params = AddInboxThreadLabelsOptions.builder()
                .labels("7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34")
                .build();

        AddInboxThreadLabelsResponseSuccess data = resend.inboxes().threads().addLabels(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadLabelAddAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    [ new Guid( "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34" ) ]
);
Console.WriteLine( "Nr Labels={0}", resp.Content.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/labels' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "labels": ["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads labels add b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 \
  --labels 7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "data": [
    {
      "id": "2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d",
      "name": "Billing",
      "color": "#00A2C7"
    },
    {
      "id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
      "name": "Urgent",
      "color": "#E93D82"
    }
  ]
}
```


# Create Draft
Source: https://resend.com/docs/api-reference/inboxes/create-draft

POST /inboxes/:inbox_id/drafts
Create a draft in an inbox, either to start a new thread or reply to an existing thread.

A draft lets you prepare a message before sending it.

Omit `thread_id` and `reply_to_email_id` to start a new thread. Pass both for a
reply draft.

An email can have only one unsent reply draft. A request for an email that
already has one returns a `200` with the existing Draft ID. It changes only the
`attachments` of that draft.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Body Parameters

At least one of `to`, `cc`, `bcc`, `subject`, `text`, `html`, or `attachments`
must be non-empty. `to`, `cc`, and `bcc` combined cannot exceed 50 recipients.

**to** `string | string[] | null`

Recipients. For multiple addresses, send an array of strings. Each value can
include a friendly name, for example `Ada Lovelace <ada@example.org>`. On a
reply draft, when you omit `to` or send `null`, the draft gets the recipients
of a [reply](/docs/api-reference/inboxes/reply-thread-email). Send `[]` for no
recipients.

**cc** `string | string[] | null`

CC recipients.

**bcc** `string | string[] | null`

BCC recipients.

**subject** `string | null`

The subject. 1 to 2000 characters, with no line breaks.

**html** `string | null`

The HTML body.

**text** `string | null`

The plain-text body.

**attachments** `array | null`

Files to store on the draft, up to 25 MB in total, downloaded files
included. All `path` downloads must finish within 20 seconds together.
Drafts do not accept `content_id`.

**properties**

**content** `buffer | string`

Content of an attached file, passed as a buffer or Base64 string. Either
`content` or `path` must be provided.

**path** `string`

Path where the attachment file is hosted. Resend downloads it when the
draft is saved, so a URL that cannot be downloaded returns an error. When
both `content` and `path` are sent, `content` is used.

**filename** `string` *required*

Name of attached file.

Content type for the attachment. Must be a valid MIME type, such as
`application/pdf`. Required with `content`. With `path`, it defaults to
the type of the downloaded file.

The Thread ID to reply in. Must be sent with `reply_to_email_id`.

The Email ID to reply to, as returned by [List Thread
Emails](/docs/api-reference/inboxes/list-thread-emails) in `data[].id`. Must be
sent with `thread_id`.

## Headers

**Idempotency-Key** `string`

Add an idempotency key to prevent duplicated drafts.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* A retry with the same key returns the first successful response, with the
  `idempotent-replayed: true` header
* A failed request is not stored, so you can retry it with the same key
* Reusing the key with a different body, or while the first request is still
  running, returns a `409`

[Learn more](/docs/dashboard/emails/idempotency-keys)

## Response Fields

**object** `string`

Always `inbox_draft`.

**id** `string`

The ID of the draft.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.create({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  to: ['ada@example.org'],
  subject: 'Refund for order 1041',
  html: '<p>Refund issued for order 1041.</p>',
  text: 'Refund issued for order 1041.',
  attachments: [
    {
      filename: 'note.txt',
      content: 'aGVsbG8=',
      contentType: 'text/plain',
    },
  ],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->create('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'to' => ['ada@example.org'],
  'subject' => 'Refund for order 1041',
  'html' => '<p>Refund issued for order 1041.</p>',
  'text' => 'Refund issued for order 1041.',
  'attachments' => [
    [
      'filename' => 'note.txt',
      'content' => 'aGVsbG8=',
      'content_type' => 'text/plain',
    ],
  ],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Drafts.CreateParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "to": ["ada@example.org"],
    "subject": "Refund for order 1041",
    "html": "<p>Refund issued for order 1041.</p>",
    "text": "Refund issued for order 1041.",
    "attachments": [
        {
            "filename": "note.txt",
            "content": "aGVsbG8=",
            "content_type": "text/plain",
        }
    ],
}

resend.Inboxes.Drafts.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  to: ["ada@example.org"],
  subject: "Refund for order 1041",
  html: "<p>Refund issued for order 1041.</p>",
  text: "Refund issued for order 1041.",
  attachments: [{ filename: "note.txt", content: "aGVsbG8=", content_type: "text/plain" }]
}

Resend::Inboxes::Drafts.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateInboxDraftRequest{
		To:      []string{"ada@example.org"},
		Subject: "Refund for order 1041",
		Html:    "<p>Refund issued for order 1041.</p>",
		Text:    "Refund issued for order 1041.",
		Attachments: []*resend.InboxDraftAttachmentInput{
			{
				Content:     []byte("hello"),
				Filename:    "note.txt",
				ContentType: "text/plain",
			},
		},
	}

	client.Inboxes.Drafts.Create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateInboxDraftAttachment, CreateInboxDraftOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = CreateInboxDraftOptions::new()
    .with_to(["ada@example.org"])
    .with_subject("Refund for order 1041")
    .with_html("<p>Refund issued for order 1041.</p>")
    .with_text("Refund issued for order 1041.")
    .with_attachment(CreateInboxDraftAttachment::new(
      b"hello".to_vec(),
      "note.txt",
      "text/plain",
    ));

  let _draft = resend
    .inboxes
    .create_draft("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", opts)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.Attachment;
import com.resend.services.inboxes.model.CreateInboxDraftOptions;
import com.resend.services.inboxes.model.CreateInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateInboxDraftOptions params = CreateInboxDraftOptions.builder()
                .to("ada@example.org")
                .subject("Refund for order 1041")
                .html("<p>Refund issued for order 1041.</p>")
                .text("Refund issued for order 1041.")
                .attachments(Attachment.builder()
                        .fileName("note.txt")
                        .content("aGVsbG8=")
                        .contentType("text/plain")
                        .build())
                .build();

        CreateInboxDraftResponseSuccess data = resend.inboxes().drafts()
                .create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxDraftCreateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxDraftCreateData()
    {
        To = "ada@example.org",
        Subject = "Refund for order 1041",
        HtmlBody = "<p>Refund issued for order 1041.</p>",
        TextBody = "Refund issued for order 1041.",
        Attachments =
        [
            new EmailAttachment()
            {
                Filename = "note.txt",
                Content = System.Text.Encoding.UTF8.GetBytes( "hello" ),
                ContentType = "text/plain",
            },
        ],
    }
);
Console.WriteLine( "Draft Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "to": ["ada@example.org"],
  "subject": "Refund for order 1041",
  "html": "<p>Refund issued for order 1041.</p>",
  "text": "Refund issued for order 1041.",
  "attachments": [
    {
      "filename": "note.txt",
      "content": "aGVsbG8=",
      "content_type": "text/plain"
    }
  ]
}'
```

```bash Reply draft theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "reply_to_email_id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  "text": "Refund issued for order 1041."
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts create b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --to ada@example.org \
  --subject "Refund for order 1041" \
  --html "<p>Refund issued for order 1041.</p>" \
  --text "Refund issued for order 1041." \
  --attachment "./note.txt;type=text/plain"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_draft",
  "id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32"
}
```


# Create Inbox
Source: https://resend.com/docs/api-reference/inboxes/create-inbox

POST /inboxes
Create an inbox to send, receive and organize email.

An inbox sends and receives email at an address on one of your domains, such as
`support@example.com`.

Without `forwarding`, the domain must have receiving enabled, with DKIM and SPF
verified and the inbound MX record verified or pending. With `forwarding` set to
`true`, the domain needs only DKIM and SPF verified. Otherwise, the request
returns a `422`. An address that is already in use
returns a `409`. A team at the inbox limit of its plan gets a `403`.

## Body Parameters

The inbox email address on one of your verified domains. The part before the
`@` can contain only letters, numbers, and `.`, `_`, `%`, and `-`, up to 64
characters. It cannot start or end with `.` or have two `.` in a row. To call
an inbox with a `%` in its address, use the Inbox ID in the path.

**name** `string`

Internal name for the inbox. Recipients do not see it. Max 64 characters.
Defaults to `email_address`.

The name recipients see when mail is sent from this inbox. Use a plain name,
without `:`, `<`, `>`, or line breaks. Max 78 characters. An email address in
the name must be on one of your verified domains.

**forwarding** `boolean` (default: false)

When `true`, Resend provisions a receiving address so you can receive mail
without adding an MX record. Read it from `receiving_address` with [Get
Inbox](/docs/api-reference/inboxes/get-inbox).

## Response Fields

**object** `string`

Always `inbox`.

**id** `string`

The ID of the inbox.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.create({
  emailAddress: 'support@example.com',
  name: 'Customer Support',
  fromName: 'Ada from Support',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->create([
  'email_address' => 'support@example.com',
  'name' => 'Customer Support',
  'from_name' => 'Ada from Support',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.CreateParams = {
    "email_address": "support@example.com",
    "name": "Customer Support",
    "from_name": "Ada from Support",
}

resend.Inboxes.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  email_address: "support@example.com",
  name: "Customer Support",
  from_name: "Ada from Support"
}

Resend::Inboxes.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateInboxRequest{
		EmailAddress: "support@example.com",
		Name:         "Customer Support",
		FromName:     "Ada from Support",
	}

	client.Inboxes.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateInboxOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = CreateInboxOptions::new("support@example.com")
    .with_name("Customer Support")
    .with_from_name("Ada from Support");

  let _inbox = resend.inboxes.create(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.CreateInboxOptions;
import com.resend.services.inboxes.model.CreateInboxResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateInboxOptions params = CreateInboxOptions.builder()
                .emailAddress("support@example.com")
                .name("Customer Support")
                .fromName("Ada from Support")
                .build();

        CreateInboxResponseSuccess data = resend.inboxes().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxCreateAsync( new InboxCreateData()
{
    EmailAddress = "support@example.com",
    Name = "Customer Support",
    FromName = "Ada from Support",
} );
Console.WriteLine( "Inbox Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "email_address": "support@example.com",
  "name": "Customer Support",
  "from_name": "Ada from Support"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes create \
  --email-address support@example.com \
  --name "Customer Support" \
  --from-name "Ada from Support"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox",
  "id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1"
}
```


# Create Label
Source: https://resend.com/docs/api-reference/inboxes/create-label

POST /inboxes/:inbox_id/labels
Create a label on an inbox.

A label is a named, colored tag that belongs to one inbox. An inbox can have at
most 100 labels. Label names are unique per inbox, compared without case. A
duplicate name returns a `422`.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Body Parameters

**name** `string` *required*

The name of the label. Max 64 characters.

**color** `string`

The color of the label as a `#RRGGBB` hex code, like `#E93D82`. Defaults to a
random color.

## Response Fields

**object** `string`

Always `inbox_label`.

**id** `string`

The ID of the label.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.labels.create({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  name: 'Urgent',
  color: '#E93D82',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->labels->create('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'name' => 'Urgent',
  'color' => '#E93D82',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Labels.CreateParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "name": "Urgent",
    "color": "#E93D82",
}

resend.Inboxes.Labels.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  name: "Urgent",
  color: "#E93D82"
}

Resend::Inboxes::Labels.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateInboxLabelRequest{
		Name:  "Urgent",
		Color: "#E93D82",
	}

	client.Inboxes.Labels.Create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateInboxLabelOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = CreateInboxLabelOptions::new("Urgent").with_color("#E93D82");

  let _label = resend
    .inboxes
    .create_label("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", opts)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.CreateInboxLabelOptions;
import com.resend.services.inboxes.model.CreateInboxLabelResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateInboxLabelOptions params = CreateInboxLabelOptions.builder()
                .name("Urgent")
                .color("#E93D82")
                .build();

        CreateInboxLabelResponseSuccess data = resend.inboxes().labels()
                .create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxLabelCreateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxLabelCreateData()
    {
        Name = "Urgent",
        Color = "#E93D82",
    }
);
Console.WriteLine( "Label Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/labels' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Urgent",
  "color": "#E93D82"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes labels create b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --name Urgent \
  --color '#E93D82'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_label",
  "id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"
}
```


# Delete Draft
Source: https://resend.com/docs/api-reference/inboxes/delete-draft

DELETE /inboxes/:inbox_id/drafts/:draft_id
Discard an unsent draft.

Discards an unsent draft. A draft that was already sent returns a `409`.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Draft ID.

## Response Fields

**object** `string`

Always `inbox_draft`.

**id** `string`

The ID of the draft.

**deleted** `boolean`

Returns `true` when the draft is deleted.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.remove({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  draftId: 'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->remove(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Drafts.remove(
    inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    draft_id="c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  draft_id: "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32"
}

Resend::Inboxes::Drafts.remove(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Drafts.Remove(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .inboxes
    .delete_draft(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.RemoveInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveInboxDraftResponseSuccess data = resend.inboxes().drafts().remove(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxDraftDeleteAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts/c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts delete b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32 \
  --yes
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_draft",
  "id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
  "deleted": true
}
```


# Delete Inbox
Source: https://resend.com/docs/api-reference/inboxes/delete-inbox

DELETE /inboxes/:inbox_id
Remove an existing inbox.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Response Fields

**object** `string`

Always `inbox`.

**id** `string`

The ID of the inbox.

**deleted** `boolean`

Returns `true` when the inbox is deleted.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.remove(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->remove('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.remove("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes.remove("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Remove("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .inboxes
    .delete("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.RemoveInboxResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveInboxResponseSuccess data = resend.inboxes().remove("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxDeleteAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes delete b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 --yes
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox",
  "id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "deleted": true
}
```


# Delete Label
Source: https://resend.com/docs/api-reference/inboxes/delete-label

DELETE /inboxes/:inbox_id/labels/:label_id
Remove an existing label from an inbox.

Deletes the label and removes it from every thread that carries it.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Label ID.

## Response Fields

**object** `string`

Always `inbox_label`.

**id** `string`

The ID of the label.

**deleted** `boolean`

Returns `true` when the label is deleted.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.labels.remove({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  labelId: '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->labels->remove(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Labels.remove(
    inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    label_id="7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  label_id: "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"
}

Resend::Inboxes::Labels.remove(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Labels.Remove(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .inboxes
    .delete_label(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.RemoveInboxLabelResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveInboxLabelResponseSuccess data = resend.inboxes().labels().remove(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxLabelDeleteAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/labels/7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes labels delete b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34 \
  --yes
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_label",
  "id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
  "deleted": true
}
```


# Delete Thread
Source: https://resend.com/docs/api-reference/inboxes/delete-thread

DELETE /inboxes/:inbox_id/threads/:thread_id
Move a thread to the trash folder.

Deleting a thread moves it to `trash` and schedules it for deletion in 30
days.

> [!NOTE]
>
> This is reversible. To restore a thread, [update
> it](/docs/api-reference/inboxes/update-thread) back to `inbox`, `archive`, or
> `spam`, which also clears the deletion deadline.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

## Response Fields

**object** `string`

Always `inbox_thread`.

**id** `string`

The ID of the thread.

**deleted** `boolean`

Returns `true` when the thread is moved to `trash`, and `false` when the
thread was already there.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.remove({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->remove(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Threads.remove(
    inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    thread_id="4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12"
}

Resend::Inboxes::Threads.remove(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Threads.Remove(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .inboxes
    .delete_thread(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.RemoveInboxThreadResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveInboxThreadResponseSuccess data = resend.inboxes().threads().remove(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxThreadDeleteAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads delete b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 \
  --yes
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_thread",
  "id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "deleted": true
}
```


# Forward Thread Email
Source: https://resend.com/docs/api-reference/inboxes/forward-thread-email

POST /inboxes/:inbox_id/threads/:thread_id/emails/:email_id/forward
Forward a message in an inbox thread to new recipients.

Forwards a message from the inbox address.

The attachments of the original message are sent with the forward, together
with any `attachments` you add. The request fails when they exceed 25 MB of
`content` in total. Files you add with `path` do not count toward it. An original
attachment that was sent from a URL (`path`) cannot be forwarded, and the
request returns a `422`. The whole email can be at most 40 MB.

The forward carries the same `In-Reply-To` and `References` headers as a
[reply](/docs/api-reference/inboxes/reply-thread-email) to the original message, so
mail clients may group it with the original conversation.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

The Email ID of the message to forward, as returned by [List Thread
Emails](/docs/api-reference/inboxes/list-thread-emails) in `data[].id`.

## Body Parameters

**to** `string | string[]` *required*

Recipient email address. For multiple addresses, send as an array of strings.
Must name at least one address. `to`, `cc`, and `bcc` combined cannot exceed
50 recipients.

**cc** `string | string[] | null`

CC recipient email address.

**bcc** `string | string[] | null`

BCC recipient email address.

**html** `string`

An HTML note sent above the quoted original.

**text** `string`

A plain-text note sent above the quoted original.

**subject** `string`

The subject of the forward. 1 to 2000 characters, with no line breaks.
Defaults to the thread subject with a `Fwd:` prefix.

**attachments** `array | null`

Files to attach, as on [Send Email](/docs/api-reference/emails/send-email).

**properties**

**content** `buffer | string`

Content of an attached file, passed as a buffer or Base64 string.

**filename** `string`

Name of attached file.

**path** `string`

Path where the attachment file is hosted.

Content type for the attachment. When not set, it is derived from the
`filename`.

Content ID for embedding inline images with a `cid:` reference in the
`html`. [Learn about inline images](/docs/dashboard/emails/embed-inline-images).

**headers** `object | null`

Custom headers to add to the email. You cannot set `In-Reply-To`,
`References`, or `Reply-To`.

## Headers

**Idempotency-Key** `string`

Add an idempotency key to prevent duplicated emails.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* A retry with the same key returns the first successful response, with the
  `idempotent-replayed: true` header
* A failed request is not stored, so you can retry it with the same key
* Reusing the key with a different body, or while the first request is still
  running, returns a `409`

[Learn more](/docs/dashboard/emails/idempotency-keys)

## Response Fields

**id** `string`

The ID of the sent email. Use it with the [emails
endpoints](/docs/api-reference/emails/retrieve-email).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.emails.forward({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  emailId: '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60',
  to: ['colleague@example.org'],
  cc: ['billing@example.com'],
  bcc: ['records@example.com'],
  text: 'Flagging this refund request for you.',
  attachments: [
    {
      path: 'https://resend.com/static/sample/invoice.pdf',
      filename: 'invoice.pdf',
    },
  ],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->emails->forward(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60',
  [
    'to' => ['colleague@example.org'],
    'cc' => ['billing@example.com'],
    'bcc' => ['records@example.com'],
    'text' => 'Flagging this refund request for you.',
    'attachments' => [
      [
        'path' => 'https://resend.com/static/sample/invoice.pdf',
        'filename' => 'invoice.pdf',
      ],
    ],
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.Emails.ForwardParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    "email_id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
    "to": ["colleague@example.org"],
    "cc": ["billing@example.com"],
    "bcc": ["records@example.com"],
    "text": "Flagging this refund request for you.",
    "attachments": [
        {
            "path": "https://resend.com/static/sample/invoice.pdf",
            "filename": "invoice.pdf",
        }
    ],
}

resend.Inboxes.Threads.Emails.forward(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  email_id: "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  to: ["colleague@example.org"],
  cc: ["billing@example.com"],
  bcc: ["records@example.com"],
  text: "Flagging this refund request for you.",
  attachments: [{ path: "https://resend.com/static/sample/invoice.pdf", filename: "invoice.pdf" }]
}

Resend::Inboxes::Threads::Emails.forward(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.ForwardInboxThreadEmailRequest{
		To:   []string{"colleague@example.org"},
		Cc:   []string{"billing@example.com"},
		Bcc:  []string{"records@example.com"},
		Text: "Flagging this refund request for you.",
		Attachments: []*resend.Attachment{
			{
				Path:     "https://resend.com/static/sample/invoice.pdf",
				Filename: "invoice.pdf",
			},
		},
	}

	client.Inboxes.Threads.Emails.Forward(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		"5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateAttachment, ForwardInboxThreadEmailOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = ForwardInboxThreadEmailOptions::new(["colleague@example.org"])
    .with_cc(["billing@example.com"])
    .with_bcc(["records@example.com"])
    .with_text("Flagging this refund request for you.")
    .with_attachment(
      CreateAttachment::from_path("https://resend.com/static/sample/invoice.pdf")
        .with_filename("invoice.pdf"),
    );

  let _forward = resend
    .inboxes
    .forward_thread_email(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
      opts,
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.Attachment;
import com.resend.services.inboxes.model.ForwardInboxThreadEmailOptions;
import com.resend.services.inboxes.model.ForwardInboxThreadEmailResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ForwardInboxThreadEmailOptions params = ForwardInboxThreadEmailOptions.builder()
                .to("colleague@example.org")
                .cc("billing@example.com")
                .bcc("records@example.com")
                .text("Flagging this refund request for you.")
                .attachments(Attachment.builder()
                        .fileName("invoice.pdf")
                        .path("https://resend.com/static/sample/invoice.pdf")
                        .build())
                .build();

        ForwardInboxThreadEmailResponseSuccess data = resend.inboxes().threads().emails().forward(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadEmailForwardAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    new Guid( "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60" ),
    new InboxThreadEmailForwardData()
    {
        To = "colleague@example.org",
        Cc = "billing@example.com",
        Bcc = "records@example.com",
        TextBody = "Flagging this refund request for you.",
        Attachments =
        [
            new EmailAttachment()
            {
                Filename = "invoice.pdf",
                Path = "https://resend.com/static/sample/invoice.pdf",
            },
        ],
    }
);
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/emails/5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60/forward' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "to": ["colleague@example.org"],
  "cc": ["billing@example.com"],
  "bcc": ["records@example.com"],
  "text": "Flagging this refund request for you.",
  "attachments": [
    {
      "path": "https://resend.com/static/sample/invoice.pdf",
      "filename": "invoice.pdf"
    }
  ]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads emails forward b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60 \
  --to colleague@example.org \
  --cc billing@example.com \
  --bcc records@example.com \
  --text "Flagging this refund request for you." \
  --attachment ./invoice.pdf
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "6a0c8e58-3d9e-4f7a-8b14-2e3f4a5b6c71"
}
```


# Retrieve Agent Settings
Source: https://resend.com/docs/api-reference/inboxes/get-agent

GET /inboxes/:inbox_id/agent
Retrieve the agent settings for an inbox.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Response Fields

**object** `string`

Always `inbox_agent`.

**instructions** `string | null`

Instructions the agent follows when handling the inbox's threads. `null` when
no instructions are set.

**tone** `'concise_professional' | 'concise_casual' | 'expanded_professional' | 'expanded_casual' | null`

Tone the agent writes in. `null` when no tone is set.

* `concise_professional`: Brief responses in a professional tone.
* `concise_casual`: Brief responses in a casual tone.
* `expanded_professional`: Detailed responses in a professional tone.
* `expanded_casual`: Detailed responses in a casual tone.

**actions** `string[]`

Actions the agent is allowed to take.

* `draft_reply`: Draft a reply.
* `forward_thread`: Forward a thread.
* `add_labels`: Add labels to a thread.
* `assign_thread`: Assign a thread.
* `mark_as_spam`: Mark a thread as spam.
* `archive`: Archive a thread.
* `move_to_trash`: Move a thread to the trash.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.agent.get({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->agent->get('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Agent.get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes::Agent.get({ inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" })
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Agent.Get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _agent = resend
    .inboxes
    .get_agent("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.GetInboxAgentResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetInboxAgentResponseSuccess data = resend.inboxes().agent()
                .get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxAgentRetrieveAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
Console.WriteLine( "Agent tone={0}", resp.Content.Tone );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/agent' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes agent get b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_agent",
  "instructions": "Answer refund questions yourself. Escalate legal threats.",
  "tone": "concise_professional",
  "actions": ["draft_reply", "add_labels"]
}
```


# Retrieve Draft
Source: https://resend.com/docs/api-reference/inboxes/get-draft

GET /inboxes/:inbox_id/drafts/:draft_id
Retrieve a single draft by its ID.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Draft ID.

## Response Fields

**object** `string`

Always `inbox_draft`.

**id** `string`

The ID of the draft.

**type** `string`

`reply` when the draft replies to an email in an existing thread. `standalone`
when the draft starts a new thread.

**to** `string[] | null`

Recipients. `null` or empty when no recipients are set.

**cc** `string[]`

CC recipients.

**bcc** `string[]`

BCC recipients.

**subject** `string | null`

The subject.

**html** `string | null`

The HTML body.

**text** `string | null`

The plain-text body.

**thread\_id** `string | null`

The Thread ID when this draft is a reply. `null` otherwise.

**reply\_to\_email\_id** `string | null`

The Email ID being replied to. `null` otherwise.

**email\_id** `string | null`

The ID of the outbound email queued when the draft was sent. `null` until the
draft is sent.

**created\_at** `string`

ISO 8601 timestamp when the draft was created.

**updated\_at** `string`

ISO 8601 timestamp when the draft was last saved.

**attachments** `array`

The files saved on the draft.

**properties**

**id** `string`

The ID of the attachment.

**filename** `string`

The filename of the attachment.

**content\_type** `string`

The MIME type of the attachment, such as `application/pdf`.

**size** `number`

The size of the attachment in bytes.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.get({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  draftId: 'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->get(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Drafts.get(
    inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    draft_id="c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  draft_id: "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32"
}

Resend::Inboxes::Drafts.get(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Drafts.Get(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _draft = resend
    .inboxes
    .get_draft(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.GetInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetInboxDraftResponseSuccess data = resend.inboxes().drafts().get(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxDraftRetrieveAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32" )
);
Console.WriteLine( "Draft subject={0}", resp.Content.Subject );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts/c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts get b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_draft",
  "id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
  "type": "standalone",
  "to": ["ada@example.org"],
  "cc": [],
  "bcc": [],
  "subject": "Refund for order 1041",
  "html": "<p>Refund issued for order 1041.</p>",
  "text": "Refund issued for order 1041.",
  "thread_id": null,
  "reply_to_email_id": null,
  "email_id": null,
  "created_at": "2026-08-05T14:12:04.110Z",
  "updated_at": "2026-08-05T14:12:04.110Z",
  "attachments": [
    {
      "id": "9d4f2b81-6c3a-4e7d-8b12-0a5c6d7e8f90",
      "filename": "note.txt",
      "content_type": "text/plain",
      "size": 5
    }
  ]
}
```


# Retrieve Inbox
Source: https://resend.com/docs/api-reference/inboxes/get-inbox

GET /inboxes/:inbox_id
Retrieve a single inbox by its ID or email address.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Response Fields

**object** `string`

Always `inbox`.

**id** `string`

The ID of the inbox.

**name** `string`

Internal name for the inbox. Recipients do not see it.

**email\_address** `string`

The address of the inbox.

**domain\_id** `string`

The ID of the domain that owns the address.

**receiving\_address** `string | null`

The address to forward mail to when forwarding is enabled. `null` otherwise.

**from\_name** `string | null`

The name recipients see when mail is sent from this inbox. `null` when not
set.

**unread** `number`

The number of unread threads in the Inbox folder.

**drafts** `number`

The number of unsent drafts.

**last\_received** `string | null`

ISO 8601 timestamp of the newest received email in the Inbox folder. `null`
when the folder has no received email.

**created\_at** `string`

ISO 8601 timestamp when the inbox was created.

**updated\_at** `string`

ISO 8601 timestamp when the inbox was updated.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.get(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->get('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes.get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _inbox = resend
    .inboxes
    .get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.GetInboxResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetInboxResponseSuccess data = resend.inboxes().get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxRetrieveAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
Console.WriteLine( "Inbox address={0}", resp.Content.EmailAddress );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes get b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox",
  "id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "name": "Customer Support",
  "email_address": "support@example.com",
  "domain_id": "d91cd9bd-1176-453e-8fc1-35364d380206",
  "receiving_address": null,
  "from_name": "Ada from Support",
  "unread": 3,
  "drafts": 2,
  "last_received": "2026-08-05T14:03:11.229Z",
  "created_at": "2026-08-01T09:12:44.512Z",
  "updated_at": "2026-08-03T16:20:05.004Z"
}
```


# Retrieve Thread
Source: https://resend.com/docs/api-reference/inboxes/get-thread

GET /inboxes/:inbox_id/threads/:thread_id
Retrieve a thread summary.

The response is the thread summary. Messages are listed separately with [List
Thread Emails](/docs/api-reference/inboxes/list-thread-emails).

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

## Response Fields

**object** `string`

Always `inbox_thread`.

**id** `string`

The ID of the thread.

**subject** `string | null`

The subject of the thread.

**folder** `string`

The folder the thread lives in. Every thread sits in exactly one folder within
its inbox. You can move a thread to `inbox`, `archive`, `spam`, or `trash`.
`sent` is assigned automatically.

* `inbox`: The default. The thread holds at least one received message.
* `archive`: The thread was archived.
* `spam`: The thread was marked as spam.
* `trash`: The thread is scheduled for deletion in 30 days.
* `sent`: Threads whose messages are all outbound.

**labels** `array`

The labels attached to the thread.

**properties**

**id** `string`

The ID of the label.

**name** `string`

The name of the label.

**color** `string`

The color of the label as an uppercase `#RRGGBB` hex code.

**read** `boolean`

True only when every message in the thread is read.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.get({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->get(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Threads.get(
    inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    thread_id="4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12"
}

Resend::Inboxes::Threads.get(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Threads.Get(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _thread = resend
    .inboxes
    .get_thread(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.GetInboxThreadResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetInboxThreadResponseSuccess data = resend.inboxes().threads().get(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadRetrieveAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" )
);
Console.WriteLine( "Thread folder={0}", resp.Content.Folder );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads get b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_thread",
  "id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "subject": "Refund for order 1041",
  "folder": "inbox",
  "labels": [
    {
      "id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
      "name": "Urgent",
      "color": "#E93D82"
    }
  ],
  "read": false
}
```


# Retrieve Thread Email
Source: https://resend.com/docs/api-reference/inboxes/get-thread-email

GET /inboxes/:inbox_id/threads/:thread_id/emails/:email_id
Retrieve a single message from a thread.

Returns one message of a thread. Each item from [List Thread
Emails](/docs/api-reference/inboxes/list-thread-emails) has this shape.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

The Email ID, as returned by [List Thread
Emails](/docs/api-reference/inboxes/list-thread-emails) in `data[].id`.

## Response Fields

**id** `string`

The ID of the message.

**direction** `string`

Whether the message was received by the inbox or sent from it. One of
`inbound` or `outbound`. A message the inbox sent to itself is `inbound`, so a
reply to it goes to its sender.

**from** `string`

Sender email address. Includes the display name when the sender has one, in
the format `Name <sender@domain.com>`.

**to** `string[]`

The recipients of the message. For a received message, these are the addresses
it was delivered to, not the full `To` header.

**cc** `string[]`

The CC recipients of the message.

**bcc** `string[]`

The BCC recipients of the message. Always empty for a received message.

**reply\_to** `string[]`

The Reply-To addresses.

**subject** `string | null`

The subject of the message.

**message\_id** `string | null`

The Message-ID header of the message.

**html** `string | null`

The HTML body.

**text** `string | null`

The plain-text body.

**attachments** `array`

The attachments on the message.

**properties**

**id** `string`

The ID of the attachment.

**filename** `string | null`

The filename of the attachment.

**size** `number | null`

The size of the attachment in bytes.

**read** `boolean`

Whether the message has been read.

**received\_at** `string`

ISO 8601 timestamp when the inbox received the message, or when the inbox sent
it.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.emails.get({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  emailId: '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->emails->get(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Threads.Emails.get(
    inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    thread_id="4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    email_id="5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  email_id: "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60"
}

Resend::Inboxes::Threads::Emails.get(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Threads.Emails.Get(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		"5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _email = resend
    .inboxes
    .get_thread_email(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.GetInboxThreadEmailResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetInboxThreadEmailResponseSuccess data = resend.inboxes().threads().emails().get(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadEmailRetrieveAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    new Guid( "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60" )
);
Console.WriteLine( "Email subject={0}", resp.Content.Subject );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/emails/5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads emails get b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  "direction": "inbound",
  "from": "Ada Lovelace <ada@example.org>",
  "to": ["support@example.com"],
  "cc": [],
  "bcc": [],
  "reply_to": ["replies@example.org"],
  "subject": "Refund for order 1041",
  "message_id": "<1041@example.org>",
  "html": "<p>Could I get a refund for order 1041?</p>",
  "text": "Could I get a refund for order 1041?",
  "attachments": [
    {
      "id": "9d4f2b81-6c3a-4e7d-8b12-0a5c6d7e8f90",
      "filename": "receipt.pdf",
      "size": 20841
    }
  ],
  "read": false,
  "received_at": "2026-08-05T14:03:11.229Z"
}
```


# List Drafts
Source: https://resend.com/docs/api-reference/inboxes/list-drafts

GET /inboxes/:inbox_id/drafts
Retrieve the unsent drafts in an inbox.

Returns the unsent drafts in the inbox, most recently updated first.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Query Parameters

**limit** `number`

Number of drafts to return. Default is `20`, maximum is `100`, minimum is `1`.

**after** `string`

The ID of the last draft on the current page. Returns the next, older page.

**before** `string`

The ID of the first draft on the current page. Returns the previous, newer
page. Cannot be combined with `after`.

## Response Fields

**object** `string`

Always `list`.

**has\_more** `boolean`

Whether more drafts exist beyond this page. Pass the last draft's `id` as
`after` to continue.

**data** `array`

The drafts on this page.

**properties**

**id** `string`

The ID of the draft.

**type** `string`

`reply` when the draft replies to an email in an existing thread.
`standalone` when the draft starts a new thread.

**to** `string[] | null`

Recipients. `null` or empty when no recipients are set.

**cc** `string[]`

CC recipients.

**bcc** `string[]`

BCC recipients.

**subject** `string | null`

The subject.

**snippet** `string | null`

A short preview of the body.

**thread\_id** `string | null`

The Thread ID when this draft is a reply. `null` otherwise.

**reply\_to\_email\_id** `string | null`

The Email ID being replied to. `null` otherwise.

**updated\_at** `string`

ISO 8601 timestamp when the draft was last saved.

**attachments** `array`

The files saved on the draft.

**properties**

**id** `string`

The ID of the attachment.

**filename** `string`

The filename of the attachment.

**content\_type** `string`

The MIME type of the attachment, such as `application/pdf`.

**size** `number`

The size of the attachment in bytes.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.list({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->list('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Drafts.list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes::Drafts.list({ inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" })
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Drafts.List("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", nil)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _drafts = resend
    .inboxes
    .list_drafts("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", ListOptions::default())
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ListInboxDraftsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListInboxDraftsResponseSuccess data = resend.inboxes().drafts()
                .list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxDraftListAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
Console.WriteLine( "Nr Drafts={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts list b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
      "type": "standalone",
      "to": ["ada@example.org"],
      "cc": [],
      "bcc": [],
      "subject": "Refund for order 1041",
      "snippet": "Refund issued for order 1041.",
      "thread_id": null,
      "reply_to_email_id": null,
      "updated_at": "2026-08-05T14:12:04.110Z",
      "attachments": [
        {
          "id": "9d4f2b81-6c3a-4e7d-8b12-0a5c6d7e8f90",
          "filename": "note.txt",
          "content_type": "text/plain",
          "size": 5
        }
      ]
    }
  ]
}
```


# List Inboxes
Source: https://resend.com/docs/api-reference/inboxes/list-inboxes

GET /inboxes
Retrieve a list of inboxes for the team.

Inboxes are returned newest first. Results are paginated with cursors. See
[Pagination](/docs/api-reference/pagination) for how `after` and `before` work. The
cursors take an inbox ID. A value that is not a UUID returns a `422`, and an
unknown ID returns a `404`.

The list items carry fewer fields than a single inbox. [Retrieve an
inbox](/docs/api-reference/inboxes/get-inbox) to get all its fields.

## Query Parameters

**limit** `number`

Number of inboxes to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more inboxes (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more inboxes (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

## Response Fields

**object** `string`

Always `list`.

**has\_more** `boolean`

Whether more inboxes exist beyond this page.

**data** `array`

The inboxes on this page.

**properties**

**id** `string`

The ID of the inbox.

**name** `string | null`

Internal name for the inbox. Recipients do not see it.

**email\_address** `string`

The address of the inbox.

**from\_name** `string | null`

The name recipients see when mail is sent from this inbox. `null` when
not set.

**unread** `number`

The number of unread threads in the Inbox folder.

**last\_received** `string | null`

ISO 8601 timestamp of the newest received email in the Inbox folder.
`null` when the folder has no received email.

**created\_at** `string`

ISO 8601 timestamp when the inbox was created.

**updated\_at** `string`

ISO 8601 timestamp when the inbox was updated.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes.list
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.List(nil)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _inboxes = resend.inboxes.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ListInboxesResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListInboxesResponseSuccess data = resend.inboxes().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxListAsync();
Console.WriteLine( "Nr Inboxes={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "name": "Customer Support",
      "email_address": "support@example.com",
      "from_name": "Ada from Support",
      "unread": 3,
      "last_received": "2026-08-05T14:03:11.229Z",
      "created_at": "2026-08-01T09:12:44.512Z",
      "updated_at": "2026-08-03T16:20:05.004Z"
    },
    {
      "id": "1c5e0f3a-6b21-4d9a-8e77-5c0a9d8b4e12",
      "name": "billing@example.com",
      "email_address": "billing@example.com",
      "from_name": null,
      "unread": 0,
      "last_received": null,
      "created_at": "2026-07-20T11:00:00.000Z",
      "updated_at": "2026-07-20T11:00:00.318Z"
    }
  ]
}
```


# List Labels
Source: https://resend.com/docs/api-reference/inboxes/list-labels

GET /inboxes/:inbox_id/labels
Retrieve the labels on an inbox.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Response Fields

**object** `string`

Always `list`.

**data** `array`

The labels on the inbox, oldest first.

**properties**

**id** `string`

The ID of the label.

**name** `string`

The name of the label.

**color** `string`

The color of the label as an uppercase `#RRGGBB` hex code, like
`#E93D82`.

**created\_at** `string`

ISO 8601 timestamp when the label was created.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.labels.list({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->labels->list('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Labels.list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes::Labels.list({ inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" })
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Labels.List("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _labels = resend
    .inboxes
    .list_labels("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ListInboxLabelsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListInboxLabelsResponseSuccess data = resend.inboxes().labels()
                .list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxLabelListAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
Console.WriteLine( "Nr Labels={0}", resp.Content.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/labels' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes labels list b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "data": [
    {
      "id": "2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d",
      "name": "Billing",
      "color": "#00A2C7",
      "created_at": "2026-08-01T09:12:03.004Z"
    },
    {
      "id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
      "name": "Urgent",
      "color": "#E93D82",
      "created_at": "2026-08-05T14:07:42.881Z"
    }
  ]
}
```


# List Thread Emails
Source: https://resend.com/docs/api-reference/inboxes/list-thread-emails

GET /inboxes/:inbox_id/threads/:thread_id/emails
Retrieve the messages in a thread.

Messages are returned oldest first. Each item has the same shape as [Retrieve
Thread Email](/docs/api-reference/inboxes/get-thread-email).

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

## Query Parameters

**limit** `number`

Number of messages to return. Default is `20`, maximum is `100`, minimum is
`1`.

**after** `string`

The ID of the last message on the current page. Returns the next, newer page.

**before** `string`

The ID of the first message on the current page. Returns the previous, older
page. Cannot be combined with `after`.

## Response Fields

**object** `string`

Always `list`.

**has\_more** `boolean`

Whether more messages exist beyond this page. Pass the last message's `id` as
`after` to continue.

**data** `array`

The messages on this page.

**properties**

**id** `string`

The ID of the message.

**direction** `string`

Whether the message was received by the inbox or sent from it. One of
`inbound` or `outbound`. A message the inbox sent to itself is `inbound`, so
a reply to it goes to its sender.

**from** `string`

Sender email address. Includes the display name when the sender has one, in
the format `Name <sender@domain.com>`.

**to** `string[]`

The recipients of the message. For a received message, these are the
addresses it was delivered to, not the full `To` header.

**cc** `string[]`

The CC recipients of the message.

**bcc** `string[]`

The BCC recipients of the message. Always empty for a received message.

**reply\_to** `string[]`

The Reply-To addresses.

**subject** `string | null`

The subject of the message.

**message\_id** `string | null`

The Message-ID header of the message.

**html** `string | null`

The HTML body.

**text** `string | null`

The plain-text body.

**attachments** `array`

The attachments on the message.

**properties**

**id** `string`

The ID of the attachment.

**filename** `string | null`

The filename of the attachment.

**size** `number | null`

The size of the attachment in bytes.

**read** `boolean`

Whether the message has been read.

**received\_at** `string`

ISO 8601 timestamp when the inbox received the message, or when the inbox
sent it.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.emails.list({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->emails->list(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Threads.Emails.list(
    inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    thread_id="4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12"
}

Resend::Inboxes::Threads::Emails.list(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Threads.Emails.List(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		nil,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _emails = resend
    .inboxes
    .list_thread_emails(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ListInboxThreadEmailsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListInboxThreadEmailsResponseSuccess data = resend.inboxes().threads().emails().list(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadEmailListAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" )
);
Console.WriteLine( "Nr Emails={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads emails list b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
      "direction": "inbound",
      "from": "Ada Lovelace <ada@example.org>",
      "to": ["support@example.com"],
      "cc": [],
      "bcc": [],
      "reply_to": ["replies@example.org"],
      "subject": "Refund for order 1041",
      "message_id": "<1041@example.org>",
      "html": "<p>Could I get a refund for order 1041?</p>",
      "text": "Could I get a refund for order 1041?",
      "attachments": [
        {
          "id": "9d4f2b81-6c3a-4e7d-8b12-0a5c6d7e8f90",
          "filename": "receipt.pdf",
          "size": 20841
        }
      ],
      "read": false,
      "received_at": "2026-08-05T14:03:11.229Z"
    }
  ]
}
```


# List Threads
Source: https://resend.com/docs/api-reference/inboxes/list-threads

GET /inboxes/:inbox_id/threads
Retrieve the threads in an inbox, filtered by folder, label, and read status.

A thread is a conversation within an inbox, made up of one or more messages.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Query Parameters

**folders** `string`

Comma-separated folders to list. Defaults to `inbox`, or to
`inbox,archive,sent` when `labels` is set.

* `inbox`: The default. The thread holds at least one received message.
* `archive`: The thread was archived.
* `spam`: The thread was marked as spam.
* `trash`: The thread is scheduled for deletion in 30 days.
* `sent`: Threads whose messages are all outbound.

**labels** `string`

Comma-separated label IDs. Returns threads with any of these labels. Up to
`50` IDs.

**read** `boolean`

`true` returns threads where every email is read. `false` returns threads with
at least one unread email.

**limit** `number`

Number of threads to return. Default is `20`, maximum is `100`, minimum is
`1`.

**after** `string`

The ID of the last thread on the current page. Returns the next, older page.
Must be a thread ID. To filter by date, use [Search
Threads](/docs/api-reference/inboxes/search-threads) with `start_date`.

**before** `string`

The ID of the first thread on the current page. Returns the previous, newer
page. Cannot be combined with `after`. Must be a thread ID. To filter by date,
use [Search Threads](/docs/api-reference/inboxes/search-threads) with `end_date`.

To find threads by text, sender, recipient, attachment, or date, use [Search
Threads](/docs/api-reference/inboxes/search-threads).

## Response Fields

**object** `string`

Always `list`.

**has\_more** `boolean`

Whether more threads exist beyond this page. Pass the last thread's `id` as
`after` to continue.

**data** `array`

The matching threads, most recently active first.

**properties**

**id** `string`

The ID of the thread.

**subject** `string | null`

The subject of the thread.

**from** `string | null`

Sender email address. Can include the display name.

**to** `string[]`

The recipients of the most recent message. For a received email, these
are the addresses it was delivered to, not the full `To` header.

**cc** `string[]`

The CC recipients of the most recent message.

**bcc** `string[]`

The BCC recipients of the most recent message. Always empty for a
received email.

**labels** `array`

The labels attached to the thread.

**properties**

**id** `string`

The ID of the label.

**name** `string`

The name of the label.

**color** `string`

The color of the label as an uppercase `#RRGGBB` hex code.

**email\_count** `number`

The number of emails in the thread.

**has\_attachment** `boolean`

Whether the most recent message in the thread has an attachment.

**has\_draft** `boolean`

Whether the thread has an unsent draft.

**read** `boolean`

True only when every message in the thread is read.

**received\_at** `string`

ISO 8601 timestamp when the thread was last active.

**folder** `string`

The folder the thread lives in. Every thread sits in exactly one folder
within its inbox. You can move a thread to `inbox`, `archive`, `spam`, or
`trash`. `sent` is assigned automatically.

* `inbox`: The default. The thread holds at least one received message.
* `archive`: The thread was archived.
* `spam`: The thread was marked as spam.
* `trash`: The thread is scheduled for deletion in 30 days.
* `sent`: Threads whose messages are all outbound.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.list({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->list('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Threads.list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes::Threads.list({ inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" })
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Threads.List("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", nil)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  list_opts::ListOptions,
  types::ListInboxThreadsOptions,
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _threads = resend
    .inboxes
    .list_threads(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      ListInboxThreadsOptions::new(),
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ListInboxThreadsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListInboxThreadsResponseSuccess data = resend.inboxes().threads()
                .list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadListAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
Console.WriteLine( "Nr Threads={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads list b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": true,
  "data": [
    {
      "id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      "subject": "Refund for order 1041",
      "from": "Ada Lovelace <ada@example.org>",
      "to": ["support@example.com"],
      "cc": [],
      "bcc": [],
      "labels": [
        {
          "id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
          "name": "Urgent",
          "color": "#E93D82"
        }
      ],
      "email_count": 2,
      "has_attachment": true,
      "has_draft": false,
      "read": false,
      "received_at": "2026-08-05T14:03:11.229Z",
      "folder": "inbox"
    }
  ]
}
```


# Remove Thread Label
Source: https://resend.com/docs/api-reference/inboxes/remove-thread-label

DELETE /inboxes/:inbox_id/threads/:thread_id/labels/:label_id
Take one label off a thread.

The label itself is kept, and stays on every other thread that carries it. To
delete the label everywhere, use
[Delete Label](/docs/api-reference/inboxes/delete-label).

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

The Label ID.

## Response Fields

**object** `string`

Always `list`.

**data** `array`

Every label on the thread after the change.

**properties**

**id** `string`

The ID of the label.

**name** `string`

The name of the label.

**color** `string`

The color of the label as an uppercase `#RRGGBB` hex code, like
`#E93D82`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.labels.remove({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  labelId: '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->labels->remove(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Threads.Labels.remove(
    inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    thread_id="4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    label_id="7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  label_id: "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"
}

Resend::Inboxes::Threads::Labels.remove(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Threads.Labels.Remove(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		"7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _labels = resend
    .inboxes
    .remove_thread_label(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.RemoveInboxThreadLabelResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveInboxThreadLabelResponseSuccess data = resend.inboxes().threads().removeLabel(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadLabelRemoveAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    new Guid( "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34" )
);
Console.WriteLine( "Nr Labels={0}", resp.Content.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/labels/7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads labels remove b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "data": [
    {
      "id": "2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d",
      "name": "Billing",
      "color": "#00A2C7"
    }
  ]
}
```


# Reply to Thread Email
Source: https://resend.com/docs/api-reference/inboxes/reply-thread-email

POST /inboxes/:inbox_id/threads/:thread_id/emails/:email_id/reply
Send a reply to a message in an inbox thread.

Sends a reply from the inbox address.

The reply goes to the `Reply-To` addresses of the message. Without them, it goes
to the sender. A reply to a message the inbox sent goes to that message's `to`
recipients.

Attachments can have at most 25 MB of `content` in total. Files sent with
`path` do not count toward it. The whole email can be at most 40 MB.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

The Email ID of the message to reply to, as returned by [List Thread
Emails](/docs/api-reference/inboxes/list-thread-emails) in `data[].id`.

## Body Parameters

At least one of `html` or `text` is required. `cc` and `bcc` combined can have
at most 49 addresses, and the whole reply at most 50 recipients.

**cc** `string | string[] | null`

CC recipient email address.

**bcc** `string | string[] | null`

BCC recipient email address.

**html** `string`

The HTML body of the reply.

**text** `string`

The plain-text body of the reply.

**subject** `string`

The subject of the reply. 1 to 2000 characters, with no line breaks. Defaults
to the thread subject with a `Re:` prefix.

Reply to everyone on the original message.

**attachments** `array | null`

Files to attach, as on [Send Email](/docs/api-reference/emails/send-email).

**properties**

**content** `buffer | string`

Content of an attached file, passed as a buffer or Base64 string.

**filename** `string`

Name of attached file.

**path** `string`

Path where the attachment file is hosted.

Content type for the attachment. When not set, it is derived from the
`filename`.

Content ID for embedding inline images with a `cid:` reference in the
`html`. [Learn about inline images](/docs/dashboard/emails/embed-inline-images).

**headers** `object | null`

Custom headers to add to the email. You cannot set `In-Reply-To`,
`References`, or `Reply-To`.

## Headers

**Idempotency-Key** `string`

Add an idempotency key to prevent duplicated emails.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* A retry with the same key returns the first successful response, with the
  `idempotent-replayed: true` header
* A failed request is not stored, so you can retry it with the same key
* Reusing the key with a different body, or while the first request is still
  running, returns a `409`

[Learn more](/docs/dashboard/emails/idempotency-keys)

## Response Fields

**id** `string`

The ID of the sent email. Use it with the [emails
endpoints](/docs/api-reference/emails/retrieve-email).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.emails.reply({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  emailId: '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60',
  cc: ['billing@example.com'],
  bcc: ['records@example.com'],
  html: '<p>Refund issued for order 1041.</p>',
  text: 'Refund issued for order 1041.',
  attachments: [
    {
      path: 'https://resend.com/static/sample/invoice.pdf',
      filename: 'invoice.pdf',
    },
  ],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->emails->reply(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60',
  [
    'cc' => ['billing@example.com'],
    'bcc' => ['records@example.com'],
    'html' => '<p>Refund issued for order 1041.</p>',
    'text' => 'Refund issued for order 1041.',
    'attachments' => [
      [
        'path' => 'https://resend.com/static/sample/invoice.pdf',
        'filename' => 'invoice.pdf',
      ],
    ],
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.Emails.ReplyParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    "email_id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
    "cc": ["billing@example.com"],
    "bcc": ["records@example.com"],
    "html": "<p>Refund issued for order 1041.</p>",
    "text": "Refund issued for order 1041.",
    "attachments": [
        {
            "path": "https://resend.com/static/sample/invoice.pdf",
            "filename": "invoice.pdf",
        }
    ],
}

resend.Inboxes.Threads.Emails.reply(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  email_id: "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  cc: ["billing@example.com"],
  bcc: ["records@example.com"],
  html: "<p>Refund issued for order 1041.</p>",
  text: "Refund issued for order 1041.",
  attachments: [{ path: "https://resend.com/static/sample/invoice.pdf", filename: "invoice.pdf" }]
}

Resend::Inboxes::Threads::Emails.reply(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.ReplyInboxThreadEmailRequest{
		Cc:   []string{"billing@example.com"},
		Bcc:  []string{"records@example.com"},
		Html: "<p>Refund issued for order 1041.</p>",
		Text: "Refund issued for order 1041.",
		Attachments: []*resend.Attachment{
			{
				Path:     "https://resend.com/static/sample/invoice.pdf",
				Filename: "invoice.pdf",
			},
		},
	}

	client.Inboxes.Threads.Emails.Reply(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		"5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateAttachment, ReplyInboxThreadEmailOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = ReplyInboxThreadEmailOptions::new()
    .with_cc(["billing@example.com"])
    .with_bcc(["records@example.com"])
    .with_html("<p>Refund issued for order 1041.</p>")
    .with_text("Refund issued for order 1041.")
    .with_attachment(
      CreateAttachment::from_path("https://resend.com/static/sample/invoice.pdf")
        .with_filename("invoice.pdf"),
    );

  let _reply = resend
    .inboxes
    .reply_thread_email(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
      opts,
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.Attachment;
import com.resend.services.inboxes.model.ReplyInboxThreadEmailOptions;
import com.resend.services.inboxes.model.ReplyInboxThreadEmailResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ReplyInboxThreadEmailOptions params = ReplyInboxThreadEmailOptions.builder()
                .cc("billing@example.com")
                .bcc("records@example.com")
                .html("<p>Refund issued for order 1041.</p>")
                .text("Refund issued for order 1041.")
                .attachments(Attachment.builder()
                        .fileName("invoice.pdf")
                        .path("https://resend.com/static/sample/invoice.pdf")
                        .build())
                .build();

        ReplyInboxThreadEmailResponseSuccess data = resend.inboxes().threads().emails().reply(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadEmailReplyAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    new Guid( "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60" ),
    new InboxThreadEmailReplyData()
    {
        Cc = "billing@example.com",
        Bcc = "records@example.com",
        HtmlBody = "<p>Refund issued for order 1041.</p>",
        TextBody = "Refund issued for order 1041.",
        Attachments =
        [
            new EmailAttachment()
            {
                Filename = "invoice.pdf",
                Path = "https://resend.com/static/sample/invoice.pdf",
            },
        ],
    }
);
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/emails/5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60/reply' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "cc": ["billing@example.com"],
  "bcc": ["records@example.com"],
  "html": "<p>Refund issued for order 1041.</p>",
  "text": "Refund issued for order 1041.",
  "attachments": [
    {
      "path": "https://resend.com/static/sample/invoice.pdf",
      "filename": "invoice.pdf"
    }
  ]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads emails reply b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60 \
  --cc billing@example.com \
  --bcc records@example.com \
  --html "<p>Refund issued for order 1041.</p>" \
  --text "Refund issued for order 1041." \
  --attachment ./invoice.pdf
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "6a0c8e58-3d9e-4f7a-8b14-2e3f4a5b6c71"
}
```


# Search Threads
Source: https://resend.com/docs/api-reference/inboxes/search-threads

GET /inboxes/:inbox_id/threads/search
Find threads in an inbox by text, people, attachments, and dates.

Search finds threads by the text of their emails, who sent or received them,
whether they have attachments, and their dates.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Query Parameters

**query** `string`

Free text to search for in the subject, body, sender, recipients, and
attachment names. Max 256 characters and 32 words.

**from** `string`

Comma-separated senders. Up to `20` values.

**to** `string`

Comma-separated recipients. Up to `20` values.

**cc** `string`

Comma-separated CC recipients. Up to `20` values.

**bcc** `string`

Comma-separated BCC recipients. Up to `20` values.

**has\_attachment** `boolean`

`true` matches emails with an attachment. `false` matches emails without one.

**start\_date** `string`

Matches emails sent on or after this date. Accepts a date like `2026-09-01` or
an ISO 8601 timestamp, in UTC unless the timestamp has an offset.

**end\_date** `string`

Matches emails sent on or before this date. Same formats as `start_date`. A
date covers that whole day, so `start_date=2026-09-01&end_date=2026-09-30`
covers all of September.

**folders** `string`

Comma-separated folders to search. Defaults to `inbox`, or to
`inbox,archive,sent` when `labels` is set.

* `inbox`: The default. The thread holds at least one received message.
* `archive`: The thread was archived.
* `spam`: The thread was marked as spam.
* `trash`: The thread is scheduled for deletion in 30 days.
* `sent`: Threads whose messages are all outbound.

**labels** `string`

Comma-separated label IDs. Returns threads with any of these labels. Up to
`50` IDs.

**read** `boolean`

`true` returns threads where every email is read. `false` returns threads with
at least one unread email.

**limit** `number`

Number of threads to return. Default is `20`, maximum is `100`, minimum is
`1`.

**after** `string`

The ID of the last thread on the current page. Returns the next, older page.
Must be a thread ID.

**before** `string`

The ID of the first thread on the current page. Returns the previous, newer
page. Cannot be combined with `after`. Must be a thread ID.

## How matching works

* `query` matches when every word appears somewhere in the email. A quoted
  phrase like `"late fee"` must appear word for word, and `-word` or
  `-"a phrase"` excludes emails that contain it. `query=invoice -draft` finds
  emails that mention `invoice` but not `draft`.
* A comma means any of: `from=isabella@example.com,carolina@example.com`
  matches emails from either. Different parameters combine, so a thread must
  match all of them.
* `folders`, `labels`, and `read` apply to the thread. `query`, `from`, `to`,
  `cc`, `bcc`, `has_attachment`, `start_date`, and `end_date` must all match
  the same email in the thread.
* When any of these email filters is set, the matching email must itself be in
  one of `folders`. For `sent`, that means an email the inbox sent.
* When more than 10,000 threads match, search covers the 10,000 with the
  newest matching email.

## Response Fields

**object** `string`

Always `list`.

**has\_more** `boolean`

Whether more threads exist beyond this page. Pass the last thread's `id` as
`after` to continue.

**data** `array`

The matching threads, most recently active first.

**properties**

**id** `string`

The ID of the thread.

**subject** `string | null`

The subject of the thread.

**from** `string | null`

Sender email address. Can include the display name.

**to** `string[]`

The recipients of the most recent message. For a received email, these
are the addresses it was delivered to, not the full `To` header.

**cc** `string[]`

The CC recipients of the most recent message.

**bcc** `string[]`

The BCC recipients of the most recent message. Always empty for a
received email.

**labels** `array`

The labels attached to the thread.

**properties**

**id** `string`

The ID of the label.

**name** `string`

The name of the label.

**color** `string`

The color of the label as an uppercase `#RRGGBB` hex code.

**email\_count** `number`

The number of emails in the thread.

**has\_attachment** `boolean`

Whether the most recent message in the thread has an attachment.

**has\_draft** `boolean`

Whether the thread has an unsent draft.

**read** `boolean`

True only when every message in the thread is read.

**received\_at** `string`

ISO 8601 timestamp when the thread was last active.

**folder** `string`

The folder the thread lives in. Every thread sits in exactly one folder
within its inbox. You can move a thread to `inbox`, `archive`, `spam`, or
`trash`. `sent` is assigned automatically.

* `inbox`: The default. The thread holds at least one received message.
* `archive`: The thread was archived.
* `spam`: The thread was marked as spam.
* `trash`: The thread is scheduled for deletion in 30 days.
* `sent`: Threads whose messages are all outbound.

**matched\_email\_id** `string | null`

Identifies the email in the thread that matched the search. When `query`
has words or phrases, it's the most relevant match. Otherwise, it's the
newest. [Retrieve Thread Email](/docs/api-reference/inboxes/get-thread-email),
reply, and forward accept it as `email_id`. It is the same `id` that
[List Thread Emails](/docs/api-reference/inboxes/list-thread-emails) returns.
`null` when the search index returns no matched email for the thread.

## Errors

Validation errors return `422` with the name `validation_error`.

| Status | Message | When |
| - | - | - |
| `422` | ``The `query` parameter must be at most 256 characters, but received 300.`` | `query` is longer than `256` characters. |
| `422` | ``The `query` parameter must contain at most 32 words, but received 40.`` | `query` has more than `32` words. |
| `422` | ``The `from` parameter must contain at most 20 values, but received 25.`` | `from`, `to`, `cc`, or `bcc` has more than `20` values. |
| `422` | ``The `start_date` must be a valid ISO 8601 date.`` | `start_date` or `end_date` isn't a date or timestamp. |
| `422` | ``The `start_date` must be on or before the `end_date`.`` | `end_date` is before `start_date`. |
| `422` | ``The `folders` value "drafts" must be one of: inbox, archive, spam, sent, trash.`` | `folders` has an unknown folder. |
| `422` | ``The `labels` value "billing" must be a valid UUID.`` | `labels` has a value that isn't a label ID. |
| `422` | ``The `labels` parameter must contain at most 50 label IDs, but received 60.`` | `labels` has more than `50` IDs. |
| `422` | `The pagination limit must be a number between 1 and 100. See https://resend.com/docs/api-reference/pagination for more information.` | `limit` is out of range. |
| `422` | ``The `read` parameter must be `true` or `false`.`` | `read` or `has_attachment` isn't `true` or `false`. |
| `422` | ``The `after` parameter must be a thread ID. To filter by date, use `GET /inboxes/:id/threads/search` with `start_date`.`` | `after` or `before` is a date. For `before`, the message names `end_date`. |
| `422` | ``You can only pass one of `before` or `after` for pagination. See https://resend.com/docs/api-reference/pagination for more information.`` | Both `after` and `before` are set. |
| `404` | `Inbox not found.` | The inbox doesn't exist. |
| `404` | `Label "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34" not found.` | A label ID in `labels` doesn't exist in the inbox. |
| `404` | `The pagination cursor references an object that does not exist. See https://resend.com/docs/api-reference/pagination for more information.` | The thread in `after` or `before` isn't in the results. |

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.search({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  query: 'invoice -draft',
  from: ['isabella@example.com', 'carolina@example.com'],
  startDate: '2026-09-01',
  limit: 2,
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->search('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'query' => 'invoice -draft',
  'from' => ['isabella@example.com', 'carolina@example.com'],
  'start_date' => '2026-09-01',
  'limit' => 2,
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.SearchParams = {
    "query": "invoice -draft",
    "from": ["isabella@example.com", "carolina@example.com"],
    "start_date": "2026-09-01",
    "limit": 2,
}

resend.Inboxes.Threads.search("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  query: "invoice -draft",
  from: ["isabella@example.com", "carolina@example.com"],
  start_date: "2026-09-01",
  limit: 2
}

Resend::Inboxes::Threads.search(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	limit := 2
	options := &resend.SearchInboxThreadsOptions{
		Query:     "invoice -draft",
		From:      []string{"isabella@example.com", "carolina@example.com"},
		StartDate: "2026-09-01",
		Limit:     &limit,
	}

	client.Inboxes.Threads.Search("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", options)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  list_opts::ListOptions,
  types::SearchInboxThreadsOptions,
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let search = SearchInboxThreadsOptions::new()
    .with_query("invoice -draft")
    .with_from(["isabella@example.com", "carolina@example.com"])
    .with_start_date("2026-09-01");

  let _threads = resend
    .inboxes
    .search_threads(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      search,
      ListOptions::default().with_limit(2),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.SearchInboxThreadsParams;
import com.resend.services.inboxes.model.SearchInboxThreadsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        SearchInboxThreadsParams params = SearchInboxThreadsParams.builder()
                .query("invoice -draft")
                .from("isabella@example.com", "carolina@example.com")
                .startDate("2026-09-01")
                .limit(2)
                .build();

        SearchInboxThreadsResponseSuccess data = resend.inboxes().threads()
                .search("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadSearchAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxThreadSearchQuery()
    {
        Query = "invoice -draft",
        From = [ "isabella@example.com", "carolina@example.com" ],
        StartDate = "2026-09-01",
        Limit = 2,
    }
);
Console.WriteLine( "Nr Threads={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl --get 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/search' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     --data-urlencode 'query=invoice -draft' \
     --data-urlencode 'from=isabella@example.com,carolina@example.com' \
     --data-urlencode 'start_date=2026-09-01' \
     --data-urlencode 'limit=2'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads search b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --query "invoice -draft" \
  --from isabella@example.com carolina@example.com \
  --start-date 2026-09-01 \
  --limit 2
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": true,
  "data": [
    {
      "id": "b1e7c9d2-5a4f-4c3e-8d2b-7f6a1e9c0b54",
      "subject": "September invoice",
      "from": "Isabella <isabella@example.com>",
      "to": ["billing@example.com"],
      "cc": [],
      "bcc": [],
      "labels": [
        {
          "id": "0c9e4b7a-3f2d-4a1c-b8e6-5d7f2a9c1e03",
          "name": "Billing",
          "color": "#46A758"
        }
      ],
      "email_count": 3,
      "has_attachment": true,
      "has_draft": false,
      "read": false,
      "received_at": "2026-09-24T14:12:08.000Z",
      "folder": "inbox",
      "matched_email_id": "e8a3f1c6-2b9d-4e5a-a7c4-9d1b6f3e2a80"
    },
    {
      "id": "7d2f8a3b-9c1e-4b6d-a5f2-3e8c0b7a9d16",
      "subject": "Re: Q3 renewal",
      "from": "Carolina <carolina@example.com>",
      "to": ["billing@example.com"],
      "cc": ["finance@example.com"],
      "bcc": [],
      "labels": [],
      "email_count": 5,
      "has_attachment": false,
      "has_draft": false,
      "read": true,
      "received_at": "2026-09-18T09:47:31.000Z",
      "folder": "inbox",
      "matched_email_id": "3c6b9e2d-7a1f-4d8c-b3e5-0f2a8d6c4b19"
    }
  ]
}
```


# Send Draft
Source: https://resend.com/docs/api-reference/inboxes/send-draft

POST /inboxes/:inbox_id/drafts/:draft_id/send
Send an existing draft from the inbox address.

Sends the draft from the inbox address.

The draft needs a `to` recipient and `html` or `text`. A draft that is not a
reply also needs a `subject`. Otherwise, the request returns a `422`. A reply
draft without a subject uses the thread subject with a `Re:` prefix. The whole
email can be at most 40 MB. A draft that was already sent returns a `409`.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Draft ID.

## Body Parameters

The request body is optional and takes only `headers`. Without headers, send no
body.

**headers** `object | null`

Custom headers to add to the email. You cannot set `In-Reply-To`,
`References`, or `Reply-To`.

## Headers

**Idempotency-Key** `string`

Add an idempotency key to prevent duplicated emails.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* A retry with the same key returns the first successful response, with the
  `idempotent-replayed: true` header
* A failed request is not stored, so you can retry it with the same key
* Reusing the key with a different body, or while the first request is still
  running, returns a `409`

[Learn more](/docs/dashboard/emails/idempotency-keys)

## Response Fields

**id** `string`

The ID of the sent email. Use it with the [emails
endpoints](/docs/api-reference/emails/retrieve-email).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.send({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  draftId: 'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->send(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Drafts.send(
    inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    draft_id="c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  draft_id: "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32"
}

Resend::Inboxes::Drafts.send(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Drafts.Send(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
		nil,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{SendInboxDraftOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _sent = resend
    .inboxes
    .send_draft(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
      SendInboxDraftOptions::new(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.SendInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        SendInboxDraftResponseSuccess data = resend.inboxes().drafts().send(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxDraftSendAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32" )
);
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts/c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32/send' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts send b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "6a0c8e58-3d9e-4f7a-8b14-2e3f4a5b6c71"
}
```


# Set Thread Labels
Source: https://resend.com/docs/api-reference/inboxes/set-thread-labels

PUT /inboxes/:inbox_id/threads/:thread_id/labels
Replace every label on a thread.

The thread ends up with exactly the labels given, in one atomic change. Labels
on the thread that are not listed are taken off, and the labels themselves are
kept. If any label ID is not found, the request returns a `404` and nothing
changes.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

## Body Parameters

**labels** `string[]` *required*

The IDs of the labels the thread should carry. Up to 100 IDs, each belonging
to the inbox. Pass an empty array to take every label off the thread.

## Response Fields

**object** `string`

Always `list`.

**data** `array`

Every label on the thread after the change.

**properties**

**id** `string`

The ID of the label.

**name** `string`

The name of the label.

**color** `string`

The color of the label as an uppercase `#RRGGBB` hex code, like
`#E93D82`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.labels.set({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  labels: ['2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d'],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->labels->set(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  [
    'labels' => ['2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d'],
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.Labels.SetParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    "labels": ["2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d"],
}

resend.Inboxes.Threads.Labels.set(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  labels: ["2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d"]
}

Resend::Inboxes::Threads::Labels.set(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.SetInboxThreadLabelsRequest{
		Labels: []string{"2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d"},
	}

	client.Inboxes.Threads.Labels.Set(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _labels = resend
    .inboxes
    .set_thread_labels(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      &["2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d"],
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.SetInboxThreadLabelsOptions;
import com.resend.services.inboxes.model.SetInboxThreadLabelsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        SetInboxThreadLabelsOptions params = SetInboxThreadLabelsOptions.builder()
                .labels("2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d")
                .build();

        SetInboxThreadLabelsResponseSuccess data = resend.inboxes().threads().setLabels(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadLabelSetAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    [ new Guid( "2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d" ) ]
);
Console.WriteLine( "Nr Labels={0}", resp.Content.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PUT 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/labels' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "labels": ["2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d"]
}'
```

```bash Clear all labels theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PUT 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/labels' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "labels": []
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads labels set b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 \
  --labels 2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "data": [
    {
      "id": "2a8b4c6d-1e3f-4a5b-9c7d-8e0f1a2b3c4d",
      "name": "Billing",
      "color": "#00A2C7"
    }
  ]
}
```


# Update Agent Settings
Source: https://resend.com/docs/api-reference/inboxes/update-agent

PATCH /inboxes/:inbox_id/agent
Update the agent settings for an inbox.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Body Parameters

Send at least one of `instructions`, `tone`, or `actions`. Omitted fields keep
their current value.

**instructions** `string | null`

Instructions the agent follows when handling the inbox's threads. 1 to 4000
characters. Whitespace at the start and end does not count. Send `null` to
clear them.

**tone** `'concise_professional' | 'concise_casual' | 'expanded_professional' | 'expanded_casual' | null`

Tone the agent writes in. Send `null` to clear it.

* `concise_professional`: Brief responses in a professional tone.
* `concise_casual`: Brief responses in a casual tone.
* `expanded_professional`: Detailed responses in a professional tone.
* `expanded_casual`: Detailed responses in a casual tone.

**actions** `string[]`

Actions the agent is allowed to take. The list replaces the current actions.
Send an empty array to disable all actions.

* `draft_reply`: Draft a reply.
* `forward_thread`: Forward a thread.
* `add_labels`: Add labels to a thread.
* `assign_thread`: Assign a thread.
* `mark_as_spam`: Mark a thread as spam.
* `archive`: Archive a thread.
* `move_to_trash`: Move a thread to the trash.

## Response Fields

**object** `string`

Always `inbox_agent`.

**id** `string`

The ID of the agent.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.agent.update({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  instructions: 'Answer refund questions yourself. Escalate legal threats.',
  tone: 'concise_professional',
  actions: ['draft_reply', 'add_labels'],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->agent->update('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'instructions' => 'Answer refund questions yourself. Escalate legal threats.',
  'tone' => 'concise_professional',
  'actions' => ['draft_reply', 'add_labels'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Agent.UpdateParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "instructions": "Answer refund questions yourself. Escalate legal threats.",
    "tone": "concise_professional",
    "actions": ["draft_reply", "add_labels"],
}

resend.Inboxes.Agent.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  instructions: "Answer refund questions yourself. Escalate legal threats.",
  tone: "concise_professional",
  actions: ["draft_reply", "add_labels"]
}

Resend::Inboxes::Agent.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	instructions := "Answer refund questions yourself. Escalate legal threats."
	tone := resend.InboxAgentToneConciseProfessional
	params := &resend.UpdateInboxAgentRequest{
		Instructions: &instructions,
		Tone:         &tone,
		Actions: []resend.InboxAgentAction{
			resend.InboxAgentActionDraftReply,
			resend.InboxAgentActionAddLabels,
		},
	}

	client.Inboxes.Agent.Update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{InboxAgentAction, InboxAgentTone, UpdateInboxAgentOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = UpdateInboxAgentOptions::new()
    .with_instructions("Answer refund questions yourself. Escalate legal threats.")
    .with_tone(InboxAgentTone::ConciseProfessional)
    .with_actions([InboxAgentAction::DraftReply, InboxAgentAction::AddLabels]);

  let _agent = resend
    .inboxes
    .update_agent("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", opts)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.InboxAgentAction;
import com.resend.services.inboxes.model.InboxAgentTone;
import com.resend.services.inboxes.model.UpdateInboxAgentOptions;
import com.resend.services.inboxes.model.UpdateInboxAgentResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxAgentOptions params = UpdateInboxAgentOptions.builder()
                .instructions("Answer refund questions yourself. Escalate legal threats.")
                .tone(InboxAgentTone.CONCISE_PROFESSIONAL)
                .actions(InboxAgentAction.DRAFT_REPLY, InboxAgentAction.ADD_LABELS)
                .build();

        UpdateInboxAgentResponseSuccess data = resend.inboxes().agent()
                .update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxAgentUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxAgentUpdateData()
    {
        Instructions = "Answer refund questions yourself. Escalate legal threats.",
        Tone = InboxAgentTone.ConciseProfessional,
        Actions = [ InboxAgentAction.DraftReply, InboxAgentAction.AddLabels ],
    }
);
Console.WriteLine( "Agent Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/agent' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "instructions": "Answer refund questions yourself. Escalate legal threats.",
  "tone": "concise_professional",
  "actions": ["draft_reply", "add_labels"]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes agent update b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --instructions "Answer refund questions yourself. Escalate legal threats." \
  --tone concise_professional \
  --actions draft_reply,add_labels
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_agent",
  "id": "a1f84a4e-6f2b-4f0a-9c1d-8a2e5b3c7d90"
}
```


# Update Draft
Source: https://resend.com/docs/api-reference/inboxes/update-draft

PATCH /inboxes/:inbox_id/drafts/:draft_id
Update an unsent draft.

Updates the content of an unsent draft. A draft that was already sent returns
a `409`.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Draft ID.

## Body Parameters

Send at least one field. Omitted fields keep their current value. A request
with `html` or `text` replaces both, and the one you leave out is saved as
`null`. After the update, the draft must still have at least one non-empty
field, and `to`, `cc`, and `bcc` combined cannot exceed 50 recipients.

**to** `string | string[] | null`

Recipients. Send `null` or `[]` to clear them.

**cc** `string | string[] | null`

CC recipients. Send `null` or `[]` to clear them.

**bcc** `string | string[] | null`

BCC recipients. Send `null` or `[]` to clear them.

**subject** `string | null`

The subject. 1 to 2000 characters, with no line breaks. Send `null` to clear
it.

**html** `string | null`

The HTML body. Send `null` to clear it.

**text** `string | null`

The plain-text body. Send `null` to clear it.

**attachments** `array | null`

Files to store on the draft, up to 25 MB in total, downloaded files
included. All `path` downloads must finish within 20 seconds together.
Sending the field replaces every attachment on the draft. Send `null` or `[]`
to remove them all. Drafts do not accept `content_id`.

**properties**

**content** `buffer | string`

Content of an attached file, passed as a buffer or Base64 string. Either
`content` or `path` must be provided.

**path** `string`

Path where the attachment file is hosted. Resend downloads it when the
draft is saved, so a URL that cannot be downloaded returns an error. When
both `content` and `path` are sent, `content` is used.

**filename** `string` *required*

Name of attached file.

Content type for the attachment. Must be a valid MIME type, such as
`application/pdf`. Required with `content`. With `path`, it defaults to
the type of the downloaded file.

## Response Fields

**object** `string`

Always `inbox_draft`.

**id** `string`

The ID of the draft.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.update({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  draftId: 'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32',
  subject: 'Refund issued for order 1041',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->update(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32',
  ['subject' => 'Refund issued for order 1041']
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Drafts.UpdateParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
    "subject": "Refund issued for order 1041",
}

resend.Inboxes.Drafts.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  draft_id: "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
  subject: "Refund issued for order 1041"
}

Resend::Inboxes::Drafts.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	subject := "Refund issued for order 1041"
	params := &resend.UpdateInboxDraftRequest{
		Subject: &subject,
	}

	client.Inboxes.Drafts.Update(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{UpdateInboxDraftOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = UpdateInboxDraftOptions::new().with_subject("Refund issued for order 1041");

  let _draft = resend
    .inboxes
    .update_draft(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
      opts,
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.UpdateInboxDraftOptions;
import com.resend.services.inboxes.model.UpdateInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxDraftOptions params = UpdateInboxDraftOptions.builder()
                .subject("Refund issued for order 1041")
                .build();

        UpdateInboxDraftResponseSuccess data = resend.inboxes().drafts().update(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxDraftUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32" ),
    new InboxDraftUpdateData()
    {
        Subject = "Refund issued for order 1041",
    }
);
Console.WriteLine( "Draft Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts/c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "subject": "Refund issued for order 1041"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts update b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32 \
  --subject "Refund issued for order 1041"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_draft",
  "id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32"
}
```


# Update Inbox
Source: https://resend.com/docs/api-reference/inboxes/update-inbox

PATCH /inboxes/:inbox_id
Update the internal inbox name or the name recipients see when sending.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

## Body Parameters

At least one of `name` or `from_name` is required. Omitted fields keep their
current value.

**name** `string`

New internal name for the inbox. Recipients do not see it. Between 1 and 64
characters after trimming.

The name recipients see when mail is sent from this inbox. Use a plain name,
without `:`, `<`, `>`, or line breaks. Max 78 characters. An email address in
the name must be on one of your verified domains. Send an empty string to
remove it.

## Response Fields

**object** `string`

Always `inbox`.

**id** `string`

The ID of the inbox.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.update(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  { name: 'Customer Support', fromName: 'Ada from Support' },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->update('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'name' => 'Customer Support',
  'from_name' => 'Ada from Support',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.UpdateParams = {
    "id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "name": "Customer Support",
    "from_name": "Ada from Support",
}

resend.Inboxes.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  name: "Customer Support",
  from_name: "Ada from Support"
}

Resend::Inboxes.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	fromName := "Ada from Support"
	params := &resend.UpdateInboxRequest{
		Name:     "Customer Support",
		FromName: &fromName,
	}

	client.Inboxes.Update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{UpdateInboxOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = UpdateInboxOptions::new()
    .with_name("Customer Support")
    .with_from_name("Ada from Support");

  let _inbox = resend
    .inboxes
    .update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", opts)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.UpdateInboxOptions;
import com.resend.services.inboxes.model.UpdateInboxResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxOptions params = UpdateInboxOptions.builder()
                .name("Customer Support")
                .fromName("Ada from Support")
                .build();

        UpdateInboxResponseSuccess data = resend.inboxes()
                .update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxUpdateData()
    {
        Name = "Customer Support",
        FromName = "Ada from Support",
    }
);
Console.WriteLine( "Inbox Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Customer Support",
  "from_name": "Ada from Support"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes update b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --name "Customer Support" \
  --from-name "Ada from Support"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox",
  "id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1"
}
```


# Update Label
Source: https://resend.com/docs/api-reference/inboxes/update-label

PATCH /inboxes/:inbox_id/labels/:label_id
Rename or recolor an existing label.

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Label ID.

## Body Parameters

Omitted fields keep their current value.

**name** `string`

A new name for the label. Max 64 characters. A name that another label in the
inbox already uses, compared without case, returns a `422`.

**color** `string`

A new color for the label as a `#RRGGBB` hex code, like `#E93D82`.

## Response Fields

**object** `string`

Always `inbox_label`.

**id** `string`

The ID of the label.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.labels.update({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  labelId: '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34',
  color: '#F76B15',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->labels->update(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34',
  ['color' => '#F76B15']
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Labels.UpdateParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
    "color": "#F76B15",
}

resend.Inboxes.Labels.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  label_id: "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
  color: "#F76B15"
}

Resend::Inboxes::Labels.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.UpdateInboxLabelRequest{
		Color: "#F76B15",
	}

	client.Inboxes.Labels.Update(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{UpdateInboxLabelOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = UpdateInboxLabelOptions::new().with_color("#F76B15");

  let _label = resend
    .inboxes
    .update_label(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
      opts,
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.UpdateInboxLabelOptions;
import com.resend.services.inboxes.model.UpdateInboxLabelResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxLabelOptions params = UpdateInboxLabelOptions.builder()
                .color("#F76B15")
                .build();

        UpdateInboxLabelResponseSuccess data = resend.inboxes().labels().update(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxLabelUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34" ),
    new InboxLabelUpdateData()
    {
        Color = "#F76B15",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/labels/7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "color": "#F76B15"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes labels update b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34 \
  --color '#F76B15'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_label",
  "id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"
}
```


# Update Thread
Source: https://resend.com/docs/api-reference/inboxes/update-thread

PATCH /inboxes/:inbox_id/threads/:thread_id
Mark a thread read or unread, or move it to another folder.

To change a thread's labels, use
[Add Thread Labels](/docs/api-reference/inboxes/add-thread-labels),
[Set Thread Labels](/docs/api-reference/inboxes/set-thread-labels), or
[Remove Thread Label](/docs/api-reference/inboxes/remove-thread-label).

## Path Parameters

The Inbox ID or the inbox email address, such as `support@example.com`.

The Thread ID.

## Body Parameters

At least one of `read` or `folder` is required. Omitted fields keep their
current value.

**read** `boolean`

Marks every message in the thread read or unread.

**folder** `string`

Moves the thread to this folder. Every thread sits in exactly one folder within
its inbox. `sent` is assigned automatically and cannot be set.

* `inbox`: The default. The thread holds at least one received message.
* `archive`: The thread was archived.
* `spam`: The thread was marked as spam.
* `trash`: The thread is scheduled for deletion in 30 days.

## Response Fields

**object** `string`

Always `inbox_thread`.

**id** `string`

The ID of the thread.

**subject** `string | null`

The subject of the thread.

**folder** `string`

The folder the thread lives in after the update.

* `inbox`: The default. The thread holds at least one received message.
* `archive`: The thread was archived.
* `spam`: The thread was marked as spam.
* `trash`: The thread is scheduled for deletion in 30 days.
* `sent`: Threads whose messages are all outbound.

**labels** `array`

The labels attached to the thread.

**properties**

**id** `string`

The ID of the label.

**name** `string`

The name of the label.

**color** `string`

The color of the label as an uppercase `#RRGGBB` hex code.

**read** `boolean`

True only when every message in the thread is read.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.update({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  read: true,
  folder: 'spam',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->update(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  [
    'read' => true,
    'folder' => 'spam',
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.UpdateParams = {
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    "read": True,
    "folder": "spam",
}

resend.Inboxes.Threads.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  inbox_id: "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id: "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  read: true,
  folder: "spam"
}

Resend::Inboxes::Threads.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	read := true
	params := &resend.UpdateInboxThreadRequest{
		Read:   &read,
		Folder: resend.InboxMoveThreadFolderSpam,
	}

	client.Inboxes.Threads.Update(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{UpdateInboxThreadFolder, UpdateInboxThreadOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = UpdateInboxThreadOptions::new()
    .with_read(true)
    .with_folder(UpdateInboxThreadFolder::Spam);

  let _thread = resend
    .inboxes
    .update_thread(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      opts,
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.MoveInboxThreadFolder;
import com.resend.services.inboxes.model.UpdateInboxThreadOptions;
import com.resend.services.inboxes.model.UpdateInboxThreadResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxThreadOptions params = UpdateInboxThreadOptions.builder()
                .read(true)
                .folder(MoveInboxThreadFolder.SPAM)
                .build();

        UpdateInboxThreadResponseSuccess data = resend.inboxes().threads().update(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    new InboxThreadUpdateData()
    {
        IsRead = true,
        Folder = InboxMoveFolder.Spam,
    }
);
Console.WriteLine( "Thread folder={0}", resp.Content.Folder );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "read": true,
  "folder": "spam"
}'
```

```bash Restore a trashed thread theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "folder": "inbox"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads update b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 \
  --read \
  --folder spam
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "inbox_thread",
  "id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "subject": "Refund for order 1041",
  "folder": "spam",
  "labels": [],
  "read": true
}
```


# Introduction
Source: https://resend.com/docs/api-reference/introduction

Understand general concepts, response codes, and authentication strategies.

> [!NOTE]
>
> For most use cases, we recommend using an [official Resend SDK](/docs/sdks) instead
> of calling the API directly. The SDKs handle authentication, required headers,
> and error handling for you. See [Resend API vs SDK](/docs/api-vs-sdk) to decide
> which fits your project.

## Base URL

The Resend API is built on **REST** principles. **HTTPS** is enforced in every request to improve data security, integrity, and privacy. The API does not support **HTTP**.

All requests contain the following base URL:

```
https://api.resend.com
```

## Authentication

To authenticate you need to add an *Authorization* header with the contents of the header being `Bearer re_xxxxxxxxx` where `re_xxxxxxxxx` is your [API Key](https://resend.com/api-keys).

```
Authorization: Bearer re_xxxxxxxxx
```

## User-Agent

All API requests must include a `User-Agent` header. Requests without this header will be rejected with a `403` status code. Most HTTP clients, all [Resend SDKs](/docs/sdks), and the [Resend CLI](/docs/cli) include this header automatically, but if you're making direct HTTP requests, make sure to set it:

```
User-Agent: my-app/1.0
```

> [!NOTE]
>
> If you're getting a `403` error with error code `1010` despite having a valid
> API key, a missing `User-Agent` header is likely the cause. See [Error
> 1010](/docs/knowledge-base/403-error-1010) for more details.

## Response codes

Resend uses standard HTTP codes to indicate the success or failure of your requests.

In general, `2xx` HTTP codes correspond to success, `4xx` codes are for user-related failures, and `5xx` codes are for infrastructure issues.

| Status | Description |
| - | - |
| `200` | Successful request. |
| `400` | Check that the parameters were correct. |
| `401` | The API key used was missing. |
| `403` | The API key used was invalid. |
| `404` | The resource was not found. |
| `429` | The rate limit was exceeded. |
| `5xx` | Indicates an error with Resend servers. |

> [!NOTE]
>
> Check [Error Codes](/docs/api-reference/errors) for a comprehensive breakdown of
> all possible API errors.

## Rate limit

The default maximum rate limit is **10 requests per second per team**. This limit applies across all API keys associated with your team. This number can be increased for trusted senders by request. You can view your team's current rate limit on the [Settings Usage page](https://resend.com/settings/usage). After that, you'll hit the rate limit and receive a `429` response error code.

Learn more about our [rate limits](/docs/api-reference/rate-limit).

## FAQ

> [accordion] How does pagination work with the API?
>
> Some endpoints support cursor-based pagination to help you browse through
> large datasets efficiently. Check our [pagination
> guide](/docs/api-reference/pagination) for detailed information on how to use
> pagination parameters.

> [accordion] How do you handle API versioning?
>
> Currently, there's no versioning system in place. We plan to add versioning
> via calendar-based headers in the future.


# List Logs
Source: https://resend.com/docs/api-reference/logs/list-logs

GET /logs
Retrieve a list of API request logs.

## Query Parameters

**limit** `number`

Number of logs to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more logs (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more logs (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.logs.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->logs->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Logs.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

logs = Resend::Logs.list
puts logs
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	logs, err := client.Logs.ListWithOptions(ctx, nil)
	if err != nil {
		panic(err)
	}

	if logs.HasMore {
		opts := &resend.ListOptions{
			After: &logs.Data[len(logs.Data)-1].Id,
		}
		client.Logs.ListWithOptions(ctx, opts)
	}
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _logs = resend
    .logs
    .list(ListOptions::default())
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        resend.logs().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Linq;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.LogListAsync();
Console.WriteLine( "Count={0}", resp.Content.Data.Count );

if ( resp.Content.HasMore )
{
    var lastId = resp.Content.Data.Last().Id;
    await resend.LogListAsync( new PaginatedQuery()
    {
        After = lastId.ToString(),
    } );
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/logs' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend logs list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "37e4414c-5e25-4dbc-a071-43552a4bd53b",
      "created_at": "2026-03-30 13:43:54.622865+00",
      "endpoint": "/emails",
      "method": "POST",
      "response_status": 200,
      "user_agent": "resend-node:6.0.3"
    },
    {
      "id": "a1b2c3d4-5e6f-7a8b-9c0d-1e2f3a4b5c6d",
      "created_at": "2026-03-30 12:15:00.123456+00",
      "endpoint": "/emails/4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "method": "GET",
      "response_status": 200,
      "user_agent": "curl/8.7.1"
    }
  ]
}
```


# Retrieve Log
Source: https://resend.com/docs/api-reference/logs/retrieve-log

GET /logs/:log_id
Retrieve a single API request log.

## Path Parameters

**log\_id** `string` *required*

The Log ID.

> [!NOTE]
>
> The `request_body` and `response_body` fields vary depending on the original
> API request that was logged.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.logs.get(
  '37e4414c-5e25-4dbc-a071-43552a4bd53b',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->logs->get('37e4414c-5e25-4dbc-a071-43552a4bd53b');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Logs.get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

log = Resend::Logs.get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
puts log
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Logs.Get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _logs = resend
    .logs
    .get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        resend.logs().get("37e4414c-5e25-4dbc-a071-43552a4bd53b");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.LogRetrieveAsync( new Guid( "37e4414c-5e25-4dbc-a071-43552a4bd53b" ) );
Console.WriteLine( "Endpoint={0}", resp.Content.Endpoint );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/logs/37e4414c-5e25-4dbc-a071-43552a4bd53b' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend logs get 37e4414c-5e25-4dbc-a071-43552a4bd53b
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "log",
  "id": "37e4414c-5e25-4dbc-a071-43552a4bd53b",
  "created_at": "2026-03-30 13:43:54.622865+00",
  "endpoint": "/emails",
  "method": "POST",
  "response_status": 200,
  "user_agent": "resend-node:6.0.3",
  "request_body": {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Hello World"
  },
  "response_body": {
    "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c"
  }
}
```


# Authorize
Source: https://resend.com/docs/api-reference/oauth/authorize

GET /oauth/authorize
Start the OAuth authorization code + PKCE flow.

This is a browser redirect endpoint, not a JSON API call. Open this URL in the user's browser. Don't fetch it from a backend or CLI process and follow the redirect yourself, since the user has to see and approve the consent screen.

The flow:

1. The client opens `/oauth/authorize` in the user's browser.
2. Resend redirects (`302`) to the Resend dashboard consent screen, which handles login if needed.
3. The user reviews and approves (or denies) the request.
4. The dashboard redirects the browser back to the client's `redirect_uri` with a `code` and the original `state`.

## Query Parameters

**client\_id** `string` *required*

The `client_id` from [registration](/docs/api-reference/oauth/register), or the
HTTPS URL of a [Client ID Metadata Document](#client-id-metadata-documents).
Resend tells the two apart by the `https://` prefix.

**response\_type** `string` *required*

Must be `"code"`.

**redirect\_uri** `string` *required*

Must exactly match one of the client's registered redirect URIs. The only
exception is loopback URIs (`127.0.0.1`, `localhost`, `[::1]`), where the port
is allowed to differ from what was registered.

**scope** `string`

Space-delimited list of requested scopes. If omitted, defaults to the client's
full registered scope set.

### Scopes

* `emails:send` is enough for send-only routes: `POST /emails`, `POST /email`,
  `POST /emails/sending`, `POST /email/sending`, and `POST
  /broadcasts/:broadcastId/send`.
* `full_access` is required for every other API route. Also satisfies any
  `emails:send`-scoped check.

**state** `string`

An opaque value round-tripped back on the callback unchanged. Use it to bind
the callback to the request that started the flow. Recommended, not required
by the server, but a client that skips it can't detect CSRF on the callback.
Maximum 1024 characters.

**code\_challenge** `string` *required*

Base64url-encoded SHA-256 hash of a
[code\_verifier](/docs/api-reference/oauth/token#param-code-verifier) your client
generates.

**code\_challenge\_method** `string` *required*

Must be `"S256"`. Resend does not support the `plain` method.

> [!NOTE]
>
> A `resource` parameter (RFC 8707) is accepted but ignored. Resend does not
> support resource indicators yet.

### Client ID Metadata Documents

A `client_id` that starts with `https://` is read as the URL of a JSON document describing the client, so the client never registers. This follows the [OAuth Client ID Metadata Document](https://datatracker.ietf.org/doc/draft-ietf-oauth-client-id-metadata-document/) draft.

This is the only endpoint that fetches the document. See [Client ID Metadata Documents](/docs/guides/building-a-resend-oauth-client#client-id-metadata-documents) for the document fields and for how Resend fetches and caches it.

```bash Browser navigation theme={"theme":{"light":"github-light","dark":"vesper"}}
GET https://api.resend.com/oauth/authorize?client_id=550e8400-e29b-41d4-a716-446655440000&response_type=code&redirect_uri=http%3A%2F%2F127.0.0.1%3A49152%2Foauth%2Fcallback&scope=emails%3Asend&state=STATE_VALUE&code_challenge=CODE_CHALLENGE_VALUE&code_challenge_method=S256
```

```http Response theme={"theme":{"light":"github-light","dark":"vesper"}}
HTTP/1.1 302 Found
Location: https://resend.com/oauth/authorize/3f9c1e2a-...
```

## Errors

Before `client_id` and `redirect_uri` are validated (unknown `client_id`, invalid or unregistered `redirect_uri`), Resend returns a JSON error body, since it can't safely redirect to an unvalidated URL.

Once Resend validates `client_id` and `redirect_uri`, errors redirect (`302`) back to `redirect_uri` with `error`, `error_description`, and (if provided) `state` as query parameters only when the `redirect_uri` is trusted: a loopback address, a private-use URI scheme, or a verified client. An unverified `https` callback gets a JSON error body instead, which prevents the endpoint from being used as an open redirect. Handle both.

| `error` | When |
| - | - |
| `invalid_request` | `response_type` isn't `code`, or `code_challenge_method` isn't `S256`. |
| `invalid_client` | Unknown or disabled `client_id`. Also a metadata document that couldn't be fetched or didn't validate. |
| `unauthorized_client` | The client isn't registered for the `authorization_code` grant. |
| `invalid_scope` | No scope requested, a scope isn't supported, or a scope isn't in the client's registered `scopes_allowed`. |
| `server_error` | Resend failed to persist the authorization request. |


# List Grants
Source: https://resend.com/docs/api-reference/oauth/list-grants

GET /oauth/grants
Retrieve a list of OAuth grants for the authenticated team.

Returns all of the team's OAuth grants, including revoked ones. A grant's
`revoked_at` and `revoked_reason` are `null` while it is active. They are set
once the grant is revoked.

## Query Parameters

**limit** `number`

Number of OAuth grants to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more OAuth grants (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more OAuth grants (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.oauthGrants.list();
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _data = resend.oauth.list(ListOptions::default()).await?;

  Ok(())
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/oauth/grants' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend oauth-grants list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "650e8400-e29b-41d4-a716-446655440001",
      "client_id": "430eed87-632a-4ea6-90db-0aace67ec228",
      "scopes": ["emails:send"],
      "resource": null,
      "created_at": "2026-04-08 00:11:13.110779+00",
      "revoked_at": null,
      "revoked_reason": null,
      "client": {
        "name": "Resend CLI",
        "logo_uri": "https://example.com/logo.png"
      }
    },
    {
      "id": "650e8400-e29b-41d4-a716-446655440002",
      "client_id": "430eed87-632a-4ea6-90db-0aace67ec228",
      "scopes": ["emails:send", "domains:read"],
      "resource": "https://api.resend.com",
      "created_at": "2026-04-07 00:11:13.110779+00",
      "revoked_at": "2026-04-09 00:11:13.110779+00",
      "revoked_reason": "revoked_from_api",
      "client": {
        "name": "Resend CLI",
        "logo_uri": "https://example.com/logo.png"
      }
    }
  ]
}
```


# Register Client
Source: https://resend.com/docs/api-reference/oauth/register

POST /oauth/register
Dynamically register an OAuth client for the authorization code + PKCE flow (RFC 7591).

Unauthenticated (no API key). Rate-limited to 20 registrations per hour per IP address.

> [!NOTE]
>
> Prefer a [Client ID Metadata
> Document](/docs/guides/building-a-resend-oauth-client#client-id-metadata-documents)
> if the client can host a static JSON file. See [Building an OAuth
> client](/docs/guides/building-a-resend-oauth-client) for choosing a registration
> method and client type.

## Body Parameters

**client\_name** `string` *required*

A human-readable name for the client. Maximum 200 characters.

**redirect\_uris** `string[]` *required*

1 to 10 URIs, each up to 2048 characters. See [Allowed redirect
URIs](#allowed-redirect-uris).

**grant\_types** `string[]` (default: \["authorization\_code", "refresh\_token"])

Must include `authorization_code`. `refresh_token` is also supported.

**response\_types** `string[]` (default: \["code"])

Only `code` is supported. Validated if present but not stored; the response
always echoes back `["code"]`.

**scope** `string`

Space-delimited list of scopes, e.g. `"emails:send"`. Must be a subset of the
[supported scopes](/docs/api-reference/oauth/authorize#scopes). If omitted, the
client is registered with every supported scope.

**token\_endpoint\_auth\_method** `string` (default: none)

How the client authenticates at the [token](/docs/api-reference/oauth/token) and
[revocation](/docs/api-reference/oauth/revoke) endpoints. `none` registers a public
client (PKCE only). `client_secret_basic` and `client_secret_post` register a
confidential client and issue a `client_secret` in the response. See
[Confidential clients](#confidential-clients). PKCE is required on every
authorization code exchange regardless of method.

**client\_uri** `string`

A URL for the client's homepage. Echoed back, not otherwise used.

**logo\_uri** `string`

A URL for the client's logo. Shown on the consent screen.

### Confidential clients

Registering with `token_endpoint_auth_method` set to `client_secret_basic` or `client_secret_post` returns two extra fields, documented in [Response Fields](#response-fields) below.

### Allowed redirect URIs

* `https://` URIs are unrestricted.
* `http://` is only allowed for loopback addresses (`127.0.0.1`, `localhost`,
  `[::1]`).
* Private-use URI schemes (e.g. `cursor://`, `vscode://`) are allowed.
* `file`, `ftp`, `data`, `javascript`, `blob`, `about`, and `vbscript` schemes
  are rejected. No URI may include a fragment.

## Response Fields

The response echoes back the registered client metadata along with the issued `client_id`. Registering a [confidential client](#confidential-clients) returns two extra fields:

**client\_secret** `string`

The generated client secret. Returned **only once**, in this response. Resend
stores a hash and can't show it again, so persist it securely at registration
time. If it's lost, register a new client.

**client\_secret\_expires\_at** `number`

Unix time at which the secret expires. Always `0`: the secret does not expire.

```bash Public client theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/register' \
     -H 'Content-Type: application/json' \
     -d $'{
  "client_name": "Example OAuth Client",
  "redirect_uris": ["http://127.0.0.1/oauth/callback"],
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"],
  "token_endpoint_auth_method": "none",
  "scope": "emails:send"
}'
```

```bash Confidential client theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/register' \
     -H 'Content-Type: application/json' \
     -d $'{
  "client_name": "Example OAuth Client",
  "redirect_uris": ["http://127.0.0.1/oauth/callback"],
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"],
  "token_endpoint_auth_method": "client_secret_basic",
  "scope": "emails:send"
}'
```

```json Public client theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "client_id": "550e8400-e29b-41d4-a716-446655440000",
  "client_id_issued_at": 1750000000,
  "client_name": "Example OAuth Client",
  "redirect_uris": ["http://127.0.0.1/oauth/callback"],
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"],
  "token_endpoint_auth_method": "none",
  "scope": "emails:send"
}
```

```json Confidential client theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "client_id": "550e8400-e29b-41d4-a716-446655440000",
  "client_id_issued_at": 1750000000,
  "client_name": "Example OAuth Client",
  "redirect_uris": ["http://127.0.0.1/oauth/callback"],
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"],
  "token_endpoint_auth_method": "client_secret_basic",
  "scope": "emails:send",
  "client_secret": "3vProAFw7...store-this-now...KpQ",
  "client_secret_expires_at": 0
}
```

## Errors

Errors use the standard OAuth shape (`{"error": "...", "error_description": "..."}`) rather than Resend's usual [error format](/docs/api-reference/errors).

| Status | `error` | When |
| - | - | - |
| `400` | `invalid_request` | A required field is missing, malformed, or a redirect URI is disallowed. |
| `400` | `invalid_scope` | `scope` includes a value outside the supported scope set. |
| `429` | `too_many_requests` | More than 20 registrations from this IP in the last hour. |


# Revoke Token
Source: https://resend.com/docs/api-reference/oauth/revoke

POST /oauth/revoke
Disconnect a client by revoking its refresh token.

RFC 7009 token revocation. Revoking a refresh token revokes the entire grant: every access and refresh token issued under it stops working.

Access tokens can't be revoked individually. Revoke the grant's refresh token instead. Per RFC 7009, this endpoint always returns `200` with an empty body.

Confidential clients must authenticate the same way they do at the [token endpoint](/docs/api-reference/oauth/token#client-authentication), using `client_secret_basic`, `client_secret_post`, or `private_key_jwt`. Public clients (`none`) send only `client_id`.

## Body Parameters

**token** `string` *required*

The refresh token to revoke.

**client\_id** `string`

Required, except with `client_secret_basic`, where the `Authorization` header
already carries it, and with `private_key_jwt`, where the assertion does.

**client\_secret** `string`

Required for a confidential client using `client_secret_post`. Omit for public
clients and for `client_secret_basic` (send the secret in the `Authorization`
header instead).

**client\_assertion\_type** `string`

Required with `private_key_jwt`. Must be
`urn:ietf:params:oauth:client-assertion-type:jwt-bearer`.

**client\_assertion** `string`

Required with `private_key_jwt`: a newly signed JWT, as at the [token
endpoint](/docs/api-reference/oauth/token#client-authentication).

**token\_type\_hint** `string`

Optional per RFC 7009. If set to `"access_token"`, the request fails: access
token revocation isn't supported. Any other value (including
`"refresh_token"`) is accepted and ignored. Unknown hints don't affect
behavior.

```bash Public client theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/revoke' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'client_id=550e8400-e29b-41d4-a716-446655440000&token=JcL7aYfE7S9h3L4qv0o2e1w8m6n5b3x9RkP2tD4uV6Q&token_type_hint=refresh_token'
```

```bash Client Secret Basic theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/revoke' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -u '550e8400-e29b-41d4-a716-446655440000:CLIENT_SECRET' \
     -d 'token=JcL7aYfE7S9h3L4qv0o2e1w8m6n5b3x9RkP2tD4uV6Q&token_type_hint=refresh_token'
```

```bash Client Secret Post theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/revoke' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'client_id=550e8400-e29b-41d4-a716-446655440000&client_secret=CLIENT_SECRET&token=JcL7aYfE7S9h3L4qv0o2e1w8m6n5b3x9RkP2tD4uV6Q&token_type_hint=refresh_token'
```

```bash Private Key JWT theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/revoke' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'client_assertion_type=urn%3Aietf%3Aparams%3Aoauth%3Aclient-assertion-type%3Ajwt-bearer&client_assertion=SIGNED_JWT&token=JcL7aYfE7S9h3L4qv0o2e1w8m6n5b3x9RkP2tD4uV6Q&token_type_hint=refresh_token'
```

```http Response theme={"theme":{"light":"github-light","dark":"vesper"}}
HTTP/1.1 200 OK
```

## Errors

| Status | `error` | When |
| - | - | - |
| `400` | `invalid_request` | `token` is missing, `client_id` is missing and neither a Basic header nor a `client_assertion` carries it, `token_type_hint` is `"access_token"`, or the client sent credentials via more than one mechanism. |
| `401` | `invalid_client` | Unknown or disabled `client_id`, or a confidential client failed authentication (missing or wrong `client_secret`, a missing, invalid, expired, or replayed `client_assertion`, or a key set that can't be used). |
| `503` | `temporarily_unavailable` | A `private_key_jwt` client's key set host timed out or answered with `429` or `5xx`, or the assertion couldn't be checked for replay. Retry the request. |


# Revoke Grant
Source: https://resend.com/docs/api-reference/oauth/revoke-grant

DELETE /oauth/grants/:oauth_grant_id
Revoke an OAuth grant for the authenticated team.

Revoking a grant invalidates every access and refresh token issued under it. Any
team API key can revoke any of the team's grants. Returns `404` if the grant
does not exist or was already revoked.

## Path Parameters

The OAuth grant ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.oauthGrants.revoke(
  '650e8400-e29b-41d4-a716-446655440001',
);
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _data = resend
    .oauth
    .revoke("650e8400-e29b-41d4-a716-446655440001")
    .await?;

  Ok(())
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/oauth/grants/650e8400-e29b-41d4-a716-446655440001' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend oauth-grants revoke 650e8400-e29b-41d4-a716-446655440001
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "oauth_grant",
  "id": "650e8400-e29b-41d4-a716-446655440001",
  "revoked_at": "2026-04-08T00:11:13.110Z",
  "revoked_reason": "revoked_from_api"
}
```


# Token
Source: https://resend.com/docs/api-reference/oauth/token

POST /oauth/token
Exchange an authorization code for tokens, or refresh an access token.

Handles two grants, selected by the `grant_type` body field: `authorization_code` (with mandatory PKCE) and `refresh_token` (with rotation and reuse detection). Accepts both `application/json` and `application/x-www-form-urlencoded`. Prefer form encoding, since that's what most OAuth libraries send by default.

Access tokens are JWTs signed with `ES256`, valid for 900 seconds. Refresh tokens are opaque strings, valid for 60 days from whenever they were last issued, and rotate on every use.

## Client authentication

How the client proves its identity depends on the `token_endpoint_auth_method` it [registered](/docs/api-reference/oauth/register#param-token-endpoint-auth-method) with:

* **Public clients (`none`)** don't send a secret. PKCE (`code_verifier`) is the only proof. This is the default and covers native, CLI, and other clients that can't keep a secret.
* **Confidential clients** additionally authenticate, on top of PKCE:
  * `client_secret_basic`: send `client_id` and `client_secret` in the HTTP `Authorization: Basic` header (each URL-encoded, joined with `:`, base64-encoded). With this method `client_id` can be omitted from the body.
  * `client_secret_post`: send `client_secret` as a body parameter alongside `client_id`.
  * `private_key_jwt`: send a JWT signed with the client's private key as `client_assertion`, with `client_assertion_type` set to `urn:ietf:params:oauth:client-assertion-type:jwt-bearer`. With this method `client_id` can be omitted from the body. See [`private_key_jwt`](/docs/guides/building-a-resend-oauth-client#private-key-jwt) for the claims the JWT must carry.

A client must use exactly one mechanism. Sending more than one, such as a Basic header and a body `client_secret`, fails with `invalid_request`.

## PKCE

Before starting the [authorization request](/docs/api-reference/oauth/authorize), generate:

* `code_verifier`: a high-entropy random string, 43–128 characters, from the
  unreserved character set (`A-Z`, `a-z`, `0-9`, `-`, `.`, `_`, `~`). Keep it
  client-side only.
* `code_challenge`: the base64url-encoded SHA-256 hash of `code_verifier`,
  sent during authorization.

```javascript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { createHash, randomBytes } from 'node:crypto';

function base64url(input) {
  return Buffer.from(input).toString('base64url');
}

const codeVerifier = base64url(randomBytes(64));
const codeChallenge = base64url(
  createHash('sha256').update(codeVerifier).digest(),
);
```

## Authorization code grant

### Body Parameters

**grant\_type** `string` *required*

Must be `"authorization_code"`.

**client\_id** `string`

Required, except with `client_secret_basic`, where the `Authorization` header
already carries it, and with `private_key_jwt`, where the assertion does.

**client\_secret** `string`

Required for a confidential client using `client_secret_post`. Omit for public
clients and for `client_secret_basic` (send the secret in the `Authorization`
header instead). See [Client authentication](#client-authentication).

**client\_assertion\_type** `string`

Required with `private_key_jwt`. Must be
`urn:ietf:params:oauth:client-assertion-type:jwt-bearer`.

**client\_assertion** `string`

Required with `private_key_jwt`: a JWT signed with the client's private key.
See [Client authentication](#client-authentication).

**code** `string` *required*

The code from the `/oauth/authorize` callback. Single-use: redeeming it twice
fails with `invalid_grant`. Expires 10 minutes after it was issued.

**redirect\_uri** `string` *required*

Must exactly match the `redirect_uri` used in the authorization request.

**code\_verifier** `string` *required*

The original value that
[code\_challenge](/docs/api-reference/oauth/authorize#param-code-challenge) was
derived from.

```bash Public client theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/token' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'grant_type=authorization_code&client_id=550e8400-e29b-41d4-a716-446655440000&code=AUTHORIZATION_CODE&redirect_uri=http%3A%2F%2F127.0.0.1%3A49152%2Foauth%2Fcallback&code_verifier=CODE_VERIFIER_VALUE'
```

```bash Client Secret Basic theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/token' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -u '550e8400-e29b-41d4-a716-446655440000:CLIENT_SECRET' \
     -d 'grant_type=authorization_code&code=AUTHORIZATION_CODE&redirect_uri=http%3A%2F%2F127.0.0.1%3A49152%2Foauth%2Fcallback&code_verifier=CODE_VERIFIER_VALUE'
```

```bash Client Secret Post theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/token' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'grant_type=authorization_code&client_id=550e8400-e29b-41d4-a716-446655440000&client_secret=CLIENT_SECRET&code=AUTHORIZATION_CODE&redirect_uri=http%3A%2F%2F127.0.0.1%3A49152%2Foauth%2Fcallback&code_verifier=CODE_VERIFIER_VALUE'
```

```bash Private Key JWT theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/token' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'grant_type=authorization_code&client_assertion_type=urn%3Aietf%3Aparams%3Aoauth%3Aclient-assertion-type%3Ajwt-bearer&client_assertion=SIGNED_JWT&code=AUTHORIZATION_CODE&redirect_uri=https%3A%2F%2Fexample.com%2Foauth%2Fcallback&code_verifier=CODE_VERIFIER_VALUE'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "access_token": "eyJhbGciOiJFUzI1NiIsImtpZCI6Im9hdXRoX2tleSIsInR5cCI6ImF0K2p3dCJ9...",
  "token_type": "Bearer",
  "expires_in": 900,
  "refresh_token": "JcL7aYfE7S9h3L4qv0o2e1w8m6n5b3x9RkP2tD4uV6Q",
  "scope": "emails:send"
}
```

### Body Parameters

**grant\_type** `string` *required*

Must be `"refresh_token"`.

**client\_id** `string`

Required, except with `client_secret_basic`, where the `Authorization` header
already carries it, and with `private_key_jwt`, where the assertion does.

**client\_secret** `string`

Required for a confidential client using `client_secret_post`. Omit for public
clients and for `client_secret_basic`. See [Client
authentication](#client-authentication).

**client\_assertion\_type** `string`

Required with `private_key_jwt`. Must be
`urn:ietf:params:oauth:client-assertion-type:jwt-bearer`.

**client\_assertion** `string`

Required with `private_key_jwt`: a JWT signed with the client's private key.
See [Client authentication](#client-authentication).

**refresh\_token** `string` *required*

**scope** `string`

Optionally narrow the scope of the new access token. Must be a subset of what
the grant already has. You can't use this to escalate scope.

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/token' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'grant_type=refresh_token&client_id=550e8400-e29b-41d4-a716-446655440000&refresh_token=JcL7aYfE7S9h3L4qv0o2e1w8m6n5b3x9RkP2tD4uV6Q'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "access_token": "eyJhbGciOiJFUzI1NiIsImtpZCI6Im9hdXRoX2tleSIsInR5cCI6ImF0K2p3dCJ9...",
  "token_type": "Bearer",
  "expires_in": 900,
  "refresh_token": "N3wRefreshTokenValue...",
  "scope": "emails:send"
}
```

## Errors

| Status | `error` | When |
| - | - | - |
| `400` | `invalid_request` | A required field is missing or malformed, or the client sent credentials via more than one mechanism (for example, both a Basic header and a body `client_secret`). |
| `400` | `invalid_scope` | Refresh requests a scope outside what the grant already has. |
| `400` | `invalid_grant` | The code/refresh token is invalid, expired, already used, or reused after rotation (which also revokes the grant). Also returned when PKCE verification fails or `redirect_uri` doesn't match. |
| `401` | `invalid_client` | Unknown or disabled `client_id`, or a confidential client failed authentication (missing or wrong `client_secret`, `client_id` in the Basic header doesn't match the request, a missing, invalid, expired, or replayed `client_assertion`, or a key set that can't be used). |
| `400` | `unauthorized_client` | The client isn't registered for the grant type it's using. |
| `503` | `temporarily_unavailable` | A `private_key_jwt` client's key set host timed out or answered with `429` or `5xx`, or the assertion couldn't be checked for replay. Retry the request. |


# Pagination
Source: https://resend.com/docs/api-reference/pagination

Learn how pagination works in the Resend API.

## Overview

Several Resend API endpoints support **cursor-based pagination** to help you efficiently browse through large datasets. You can safely navigate lists with guaranteed stability, even if new objects are created or deleted while you're still requesting pages.

Paginated endpoints responses include:

* `object`: always set to `list`.
* `has_more`: indicates whether there are more elements available.
* `data`: the list of returned items.

You can navigate through the results using the following parameters:

* `limit`: the number of items to return per page.
* `after`: the cursor to use to get the next page of results.
* `before`: the cursor to use to get the previous page of results.

Use the `id` of objects as the cursor for pagination. The cursor itself is *excluded* from the results. For an example, see [pagination strategies below](#strategies).

## Supported endpoints

The following list endpoints support cursor-based pagination.

### Endpoints that default to 20 items

Most paginated endpoints return 20 items by default when `limit` is not provided:

* [List Automations](/docs/api-reference/automations/list-automations)
* [List Automation Runs](/docs/api-reference/automations/list-automation-runs)
* [List Broadcast Clicked Links](/docs/api-reference/broadcasts/list-broadcast-clicked-links)
* [List Broadcast Recipients](/docs/api-reference/broadcasts/list-broadcast-recipients)
* [List Contact Properties](/docs/api-reference/contact-properties/list-contact-properties)
* [List Contacts](/docs/api-reference/contacts/list-contacts)
* [List Contact Segments](/docs/api-reference/contacts/list-contact-segments)
* [Get Contact Topics](/docs/api-reference/contacts/get-contact-topics)
* [List Emails](/docs/api-reference/emails/list-emails)
* [List Email Attachments](/docs/api-reference/emails/list-email-attachments)
* [List Receiving Emails](/docs/api-reference/emails/list-received-emails)
* [List Receiving Email Attachments](/docs/api-reference/emails/list-received-email-attachments)
* [List Events](/docs/api-reference/events/list-events)
* [List Inboxes](/docs/api-reference/inboxes/list-inboxes)
* [List Threads](/docs/api-reference/inboxes/list-threads)
* [Search Threads](/docs/api-reference/inboxes/search-threads)
* [List Thread Emails](/docs/api-reference/inboxes/list-thread-emails)
* [List Drafts](/docs/api-reference/inboxes/list-drafts)
* [List Logs](/docs/api-reference/logs/list-logs)
* [List OAuth Grants](/docs/api-reference/oauth/list-grants)
* [List Suppressions](/docs/api-reference/suppressions/list-suppressions)
* [List Templates](/docs/api-reference/templates/list-templates)
* [List Topics](/docs/api-reference/topics/list-topics)
* [List Webhooks](/docs/api-reference/webhooks/list-webhooks)
* [List Webhook Events](/docs/api-reference/webhooks/list-events)
* [List Event Attempts](/docs/api-reference/webhooks/list-event-attempts)

### Endpoints that return all items by default

The following endpoints return all items in a single response when `limit` is not provided. Pass `limit` to paginate and set the page size. The `after` and `before` parameters only take effect together with `limit`.

* [List API Keys](/docs/api-reference/api-keys/list-api-keys)
* [List Audiences](/docs/api-reference/audiences/list-audiences) (deprecated, alias for Segments)
* [List Broadcasts](/docs/api-reference/broadcasts/list-broadcasts)
* [List Domains](/docs/api-reference/domains/list-domains)
* [List Segments](/docs/api-reference/segments/list-segments)
* [List Segment Contacts](/docs/api-reference/segments/list-segment-contacts)

### Other endpoints

* [List Contact Imports](/docs/api-reference/contacts/list-contact-imports) defaults to **10 items** when `limit` is not provided

## Parameters

Paginated endpoints accept the following query parameters:

**limit** `number`

The number of items to return per page. The maximum is `100` and the minimum
is `1`. The default depends on the endpoint. See [Supported
endpoints](#supported-endpoints).

**after** `string`

The cursor after which to start retrieving items. To get the next page, use
the ID of the last item from the current page. This will return the page that
**starts after** the object with this ID (excluding the passed ID itself).

**before** `string`

The cursor before which to start retrieving items. To get the previous page,
use the ID of the first item from the current page. This will return the page
that **ends before** the object with this ID (excluding the passed ID itself).
[List Webhook Events](/docs/api-reference/webhooks/list-events) and [List Event
Attempts](/docs/api-reference/webhooks/list-event-attempts) do not support
`before`.

> [!WARNING]
>
> You can only use either `after` or `before`, not both simultaneously.

## Response Fields

Paginated endpoints return responses in the following format:

```json Response Format theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": true,
  "data": [/* Array of resources */]
}
```

**object** `string`

Always set to `list` for paginated responses.

**has\_more** `boolean`

Indicates whether there are more items available beyond the current page.

**data** `array`

An array containing the actual resources for the current page.

## Strategies

### Forward Pagination

To paginate forward through results (newer to older items), use the `after` parameter with the ID of the **last item** from the current page:

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('re_xxxxxxxxx');

// First page
const { data: firstPage } = await resend.contacts.list({ limit: 50 });

// Second page (if has_more is true)
if (firstPage.has_more) {
  const lastId = firstPage.data[firstPage.data.length - 1].id;
  const { data: secondPage } = await resend.contacts.list({
    limit: 50,
    after: lastId,
  });
}
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// First page
$firstPage = $resend->contacts->list(['limit' => 50]);

// Second page (if has_more is true)
if ($firstPage['has_more']) {
    $lastId = end($firstPage['data'])['id'];
    $secondPage = $resend->contacts->list([
        'limit' => 50,
        'after' => $lastId
    ]);
}
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# First page
first_page = resend.Contacts.list(limit=50)

# Second page (if has_more is true)
if first_page['has_more']:
    last_id = first_page['data'][-1]['id']
    second_page = resend.Contacts.list(limit=50, after=last_id)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
Resend.api_key = "re_xxxxxxxxx"

# First page
first_page = Resend::Contacts.list(limit: 50)

# Second page (if has_more is true)
if first_page['has_more']
  last_id = first_page['data'].last['id']
  second_page = Resend::Contacts.list(limit: 50, after: last_id)
end
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// First page
	firstPage, err := client.Contacts.List(&resend.ListContactsRequest{
		Limit: 50,
	})

	// Second page (if has_more is true)
	if firstPage.HasMore {
		lastId := firstPage.Data[len(firstPage.Data)-1].ID
		client.Contacts.List(&resend.ListContactsRequest{
			Limit: 50,
			After: lastId,
		})
	}
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, types::ListContactOptions};

#[tokio::main]
async fn main() -> Result<()> {
    let resend = Resend::new("re_xxxxxxxxx");

    // First page
    let list_opts = ListContactOptions::default().with_limit(50);
    let first_page = resend.emails.list(list_opts).await?;

    // Second page (if has_more is true)
    if first_page.has_more {
        let last_id = &first_page.data.last().unwrap().id;
        let list_opts = ListContactOptions::default()
            .with_limit(10)
            .list_after(last_id);
        let second_page = resend.contacts.list(list_opts).await?;
    }

    Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;

public class Main {
    public static void main(String[] args) {
        Resend resend = new Resend("re_xxxxxxxxx");

        // First page
        ListEmailsResponse firstPage = resend.emails().list(10);

        // Second page (if has_more is true)
        if (firstPage.getHasMore()) {
            String lastId = firstPage.getData().get(firstPage.getData().size() - 1).getId();
            ListContactsResponse secondPage = resend.contacts().list(50, lastId, null);
        }
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Linq;

IResend resend = ResendClient.Create("re_xxxxxxxxx");

// First page
var firstPage = await resend.EmailListAsync( new PaginatedQuery() {
  Limit = 50,
});

// Second page (if has_more is true)
if (firstPage.Content.HasMore)
{
    var lastId = firstPage.Content.Data.Last().Id;
    var secondPage = await resend.EmailListAsync( new PaginatedQuery() {
      Limit = 50,
      After = lastId.ToString(),
    });
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# First page
curl -X GET 'https://api.resend.com/contacts?limit=50' \
     -H 'Authorization: Bearer re_xxxxxxxxx'

# Second page
curl -X GET 'https://api.resend.com/contacts?limit=50&after=LAST_ID_FROM_PREVIOUS_PAGE' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

### Backward Pagination

To paginate backward through results (older to newer items), use the `before` parameter with the ID of the **first item** from the current page (or the most recent ID you have in your system):

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('re_xxxxxxxxx');

// Start from a specific point and go backward
const page = await resend.contacts.list({
  limit: 50,
  before: 'some-contact-id',
});

if (page.data.has_more) {
  const firstId = page.data.data[0].id;
  const previousPage = await resend.contacts.list({
    limit: 50,
    before: firstId,
  });
}
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Start from a specific point and go backward
$page = $resend->contacts->list([
    'limit' => 50,
    'before' => 'some-contact-id'
]);

if ($page['has_more']) {
    $firstId = $page['data'][0]['id'];
    $previousPage = $resend->contacts->list([
        'limit' => 50,
        'before' => $firstId
    ]);
}
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Start from a specific point and go backward
page = resend.Contacts.list(limit=50, before="some-contact-id")

if page["has_more"]:
    first_id = page["data"][0]["id"]
    previous_page = resend.Contacts.list(limit=50, before=first_id)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
Resend.api_key = "re_xxxxxxxxx"

# Start from a specific point and go backward
page = Resend::Contacts.list(limit: 50, before: 'some-contact-id')

if page['has_more']
  first_id = page['data'].first['id']
  previous_page = Resend::Contacts.list(limit: 50, before: first_id)
end
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Start from a specific point and go backward
	page, err := client.Contacts.List(&resend.ListContactsRequest{
		Limit:  resend.Int(50),
		Before: resend.String("some-contact-id"),
	})

	if page.HasMore {
		firstId := page.Data[0].ID
		client.Contacts.List(&resend.ListContactsRequest{
			Limit:  resend.Int(50),
			Before: resend.String(firstId),
		})
	}
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, types::ListContactOptions};

#[tokio::main]
async fn main() -> Result<()> {
    let resend = Resend::new("re_xxxxxxxxx");

    // Start from a specific point and go backward
    let list_opts = ListContactOptions::default()
        .with_limit(50)
        .list_before("some-email-id");
    let page = resend.contacts.list(list_opts).await?;

    if page.has_more {
        let first_id = &page.data.first().unwrap().id;
        let list_opts = ListContactOptions::default()
            .with_limit(10)
            .list_before(first_id);
        let previous_page = resend.contacts.list(list_opts).await?;
    }

    Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;

public class Main {
    public static void main(String[] args) {
        Resend resend = new Resend("re_xxxxxxxxx");

        // Start from a specific point and go backward
        ListContactsResponse page = resend.contacts().list(50, null, "some-contact-id");

        if (page.getHasMore()) {
            String firstId = page.getData().get(0).getId();
            ListContactsResponse previousPage = resend.contacts().list(50, null, firstId);
        }
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Linq;

IResend resend = ResendClient.Create("re_xxxxxxxxx");

// Start from a specific point and go backward
var page = await resend.EmailListAsync( new PaginatedQuery() {
  Limit = 50,
  Before = "some-email-id",
});

if (page.Content.HasMore)
{
    var firstId = page.Content.Data.First().Id;
    var prevPage = await resend.EmailListAsync( new PaginatedQuery() {
      Limit = 50,
      Before = firstId.ToString(),
    });
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/contacts?limit=50&before=some-contact-id' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

## Best Practices

> [accordion] Use appropriate page sizes
>
> Choose a `limit` that balances performance and usability. Smaller pages are good for real-time applications, while larger pages
> (hundreds of items) work better for bulk processing.

> [accordion] Handle pagination gracefully
>
> Always check the `has_more` field before attempting to fetch additional pages.
> This prevents unnecessary API calls when you've reached the end of the
> dataset.

> [accordion] Consider rate limits
>
> Be mindful of API rate limits when paginating through large datasets.
> Implement appropriate delays or batching strategies if processing many
> pages.

## Error Handling

Pagination requests may return the following validation errors:

| Error | Description |
| - | - |
| `validation_error` | Invalid cursor format or limit out of range (1–100) |
| `validation_error` | Both `before` and `after` parameters provided |

Example error response:

```json Error Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "name": "validation_error",
  "statusCode": 422,
  "message": "The pagination limit must be a number between 1 and 100. See https://resend.com/docs/pagination for more information."
}
```


# Usage Limits
Source: https://resend.com/docs/api-reference/rate-limit

Learn about API rate limits, email sending quotas, and contact quotas.

The Resend API enforces three types of limits: **rate limits** control how many API requests you can make per second, **email quotas** control the total number of emails you can send per day and month, and **contact quotas** control how many marketing contacts you can store.

## Rate Limits

### Response Headers

The response headers describe your current rate limit following every request in conformance with the [sixth IETF standard draft](https://datatracker.ietf.org/doc/html/draft-ietf-httpapi-ratelimit-headers-06):

| Header name | Description |
| - | - |
| `ratelimit-limit` | Maximum number of requests allowed within a window. |
| `ratelimit-remaining` | How many requests you have left within the current window. |
| `ratelimit-reset` | How many seconds until the limits are reset. |
| `retry-after` | How many seconds to wait before making a follow-up request. |

The default maximum rate limit is **10 requests per second per team**. This limit applies across all API keys associated with your team. This number can be increased for trusted senders upon request. You can view your team's current rate limit on the [Settings Usage page](https://resend.com/settings/usage).

After that, you'll hit the rate limit and receive a `429` response error code. You can find all 429 responses by filtering for 429 at the [Resend Logs page](https://resend.com/logs?status=429).

To prevent this, reduce the rate at which you request the API. This can be done by introducing a queue mechanism or reducing the number of concurrent requests per second. If you have specific requirements, [contact support](https://resend.com/help) to request a rate increase.

## Email Quotas

### Response Headers

In addition to rate limits, the API returns headers that track your email sending quotas:

| Header name | Description |
| - | - |
| `x-resend-daily-quota` | Your used daily email sending quota. Only sent to free plan users. |
| `x-resend-monthly-quota` | Your used monthly email sending quota. |

These headers help you monitor your usage and avoid hitting quota limits.

The daily quota applies only to the Free plan. It is a UTC calendar day (00:00–24:00 UTC) and resets at midnight UTC — not a rolling 24-hour window. Paid sending plans have no daily quota, only the monthly limit.

When you exceed your quota limits, you'll receive a `429` response error code with one of the following error types:

* **`daily_quota_exceeded`** - You have reached your daily email quota. [Upgrade your plan](https://resend.com/settings/billing) to remove the daily quota limit or wait for the quota to reset at midnight UTC.
* **`monthly_quota_exceeded`** - You have reached your monthly email quota. [Upgrade your plan](https://resend.com/settings/billing) to increase the monthly email quota.

Both sent and received emails count towards these quotas. See the full list of [error codes](/docs/api-reference/errors) for more details.

## Contact Quotas

Contact quotas restrict the number of contacts you can store for marketing emails and broadcasts. You can add more contacts beyond your plan's limit, but you won't be able to send broadcasts until you upgrade your plan or remove contacts to get back within the limit.

When you attempt to send a broadcast after reaching your contact limit, you'll receive a `403` response error code with a `validation_error` type and the message: "You have reached your contacts quota. Please upgrade your plan to send more emails."

To increase your contact limit, [upgrade your Marketing plan](https://resend.com/settings/billing).


# Create Segment
Source: https://resend.com/docs/api-reference/segments/create-segment

POST /segments
Create a new segment for contacts to be added to.

## Body Parameters

**name** `string` *required*

The name of the segment you want to create.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.segments.create({
  name: 'Registered Users',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->segments->create([
  'name' => 'Registered Users',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

params: resend.Segments.CreateParams = {
    "name": "Registered Users",
}

segment = resend.Segments.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "Registered Users",
}
segment = Resend::Segments.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateSegmentRequest{
		Name: "Registered Users",
	}

	segment, err := client.Segments.CreateWithContext(ctx, params)
	if err != nil {
		panic(err)
	}
	fmt.Println(segment)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _segment = resend.segments.create("Registered Users").await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.segments.model.CreateSegmentOptions;
import com.resend.services.segments.model.CreateSegmentResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateSegmentOptions options = CreateSegmentOptions.builder()
            .name("Registered Users")
            .build();

        CreateSegmentResponseSuccess response = resend.segments().create(options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.SegmentCreateAsync( new SegmentData() {
  Name = "Registered Users",
} );
Console.WriteLine( "Segment Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/segments' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Registered Users"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend segments create --name "Registered Users"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "segment",
  "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "name": "Registered Users"
}
```


# Delete Segment
Source: https://resend.com/docs/api-reference/segments/delete-segment

DELETE /segments/:segment_id
Remove an existing segment.

## Path Parameters

The Segment ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.segments.remove(
  '78261eea-8f8b-4381-83c6-79fa7120f1cf',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->segments->remove('78261eea-8f8b-4381-83c6-79fa7120f1cf');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

segment = resend.Segments.remove(id='78261eea-8f8b-4381-83c6-79fa7120f1cf')
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Segments.remove("78261eea-8f8b-4381-83c6-79fa7120f1cf")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	segment, err := client.Segments.RemoveWithContext(ctx, "78261eea-8f8b-4381-83c6-79fa7120f1cf")
	if err != nil {
		panic(err)
	}
	fmt.Println(segment)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _segment = resend
    .segments
    .delete("78261eea-8f8b-4381-83c6-79fa7120f1cf")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.segments.model.RemoveSegmentResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveSegmentResponseSuccess response = resend.segments().remove("78261eea-8f8b-4381-83c6-79fa7120f1cf");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.SegmentDeleteAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend segments delete 78261eea-8f8b-4381-83c6-79fa7120f1cf
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "segment",
  "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "deleted": true
}
```


# Retrieve Segment
Source: https://resend.com/docs/api-reference/segments/get-segment

GET /segments/:segment_id
Retrieve a single segment.

## Path Parameters

The Segment ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.segments.get(
  '78261eea-8f8b-4381-83c6-79fa7120f1cf',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->segments->get('78261eea-8f8b-4381-83c6-79fa7120f1cf');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

segment = resend.Segments.get('78261eea-8f8b-4381-83c6-79fa7120f1cf')
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

segment = Resend::Segments.get("78261eea-8f8b-4381-83c6-79fa7120f1cf")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	segment, err := client.Segments.GetWithContext(ctx, "78261eea-8f8b-4381-83c6-79fa7120f1cf")
	if err != nil {
		panic(err)
	}
	fmt.Println(segment)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _segment = resend
    .segments
    .get("78261eea-8f8b-4381-83c6-79fa7120f1cf")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.segments.model.GetSegmentResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetSegmentResponseSuccess response = resend.segments().get("78261eea-8f8b-4381-83c6-79fa7120f1cf");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.SegmentRetrieveAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
Console.WriteLine( "Segment Id={0}", resp.Content.Id );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend segments get 78261eea-8f8b-4381-83c6-79fa7120f1cf
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "segment",
  "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "name": "Registered Users",
  "created_at": "2026-10-06 22:59:55.977+00"
}
```


# Retrieve Metrics
Source: https://resend.com/docs/api-reference/segments/get-segment-metrics

GET /segments/metrics
Retrieve segment metrics.

> [!WARNING]
>
> Segment metrics are currently in private beta and only available to a limited
> number of users. The response shape might change before GA. [Get in
> touch](https://resend.com/help) if you're interested in testing this
> feature.
>
> Once you have access, upgrade your Resend SDK to use the methods on this
> page:
>
> ```bash Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
> npm install resend@6.31.1-preview-headless-dashboard.0
> ```

Contact counts for your account, optionally broken down by segment. Works
across your whole account by default, or scoped to specific segments via
`segment_id`.

> [!NOTE]
>
> Responses are cached for up to 15 minutes, so repeating the same request may
> return slightly stale data within that window.

All parameters are optional. With none, the response covers your whole account,
includes every metric, and returns only `totals`. There's no date range, so
counts are a point-in-time snapshot rather than a historical window.

## Query Parameters

List-type query parameters below accept a comma-separated value, the
parameter repeated (`segment_id=a&segment_id=b`), or a mix of
both.

List of metrics to include in `totals` and `data`. Omit for all. See
[Metrics](#metrics).

List of dimensions to break `data` down by. Omit for only `totals`, with no
`data`.

Possible values:

* `segment`: one row per segment, using its current contact counts.

List of segment IDs. Narrows `totals` (and `data`, when requested) to just
these segments, without double-counting contacts that belong to more than one.

> [!NOTE]
>
> When `dimensions` includes `segment`, `data` is ordered by each segment's
> creation date, newest first.

## Metrics

Every metric counts contacts, not emails.

| Metric | Description |
| - | - |
| `all_contacts` | Every contact. Sum of `subscribers` and `unsubscribers`. |
| `subscribers` | Contacts with `unsubscribed` set to `false`. |
| `unsubscribers` | Contacts with `unsubscribed` set to `true`. |

> [!NOTE]
>
> `totals` counts each contact once. `data` counts a contact in every segment it
> belongs to.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.segments.metrics({
  dimensions: ['segment'],
  metrics: ['all_contacts'],
});
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/segments/metrics?dimensions=segment&metrics=all_contacts' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "metrics",
  "metrics": ["all_contacts"],
  "dimensions": ["segment"],
  "totals": {
    "all_contacts": 12450
  },
  "data": [
    {
      "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      "name": "Registered Users",
      "all_contacts": 4300
    }
  ]
}
```


# List Segment Contacts
Source: https://resend.com/docs/api-reference/segments/list-segment-contacts

GET /segments/:segment_id/contacts
Retrieve a list of contacts in a segment.

## Path Parameters

The Segment ID.

## Query Parameters

If `limit` is not provided, all contacts will be returned
in a single response. Pass `limit` to paginate.
`after` and `before` only take effect together
with `limit`.

**limit** `number`

Number of contacts to retrieve.
<ul><li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more contacts (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more contacts (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.list({
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contacts->list([
  'segment_id' => '78261eea-8f8b-4381-83c6-79fa7120f1cf',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

contacts = resend.Contacts.list(segment_id='78261eea-8f8b-4381-83c6-79fa7120f1cf')
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

contacts = Resend::Contacts.list(segment_id: '78261eea-8f8b-4381-83c6-79fa7120f1cf')
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	contacts, err := client.Contacts.ListWithContext(ctx, &resend.ListContactsOptions{
		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(contacts)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _contacts = resend
    .segments
    .list_contacts(
      "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.ListContactsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListContactsResponseSuccess response = resend.contacts().list("78261eea-8f8b-4381-83c6-79fa7120f1cf");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.SegmentListContactsAsync( new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ) );
Console.WriteLine( "Nr Contacts={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf/contacts' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend segments contacts 78261eea-8f8b-4381-83c6-79fa7120f1cf
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "email": "steve.wozniak@gmail.com",
      "first_name": "Steve",
      "last_name": "Wozniak",
      "created_at": "2026-10-06 23:47:56.678+00",
      "unsubscribed": false
    }
  ]
}
```


# List Segments
Source: https://resend.com/docs/api-reference/segments/list-segments

GET /segments
Retrieve a list of segments.

## Query Parameters

If `limit` is not provided, all segments will be returned
in a single response. Pass `limit` to paginate.
`after` and `before` only take effect together
with `limit`.

**limit** `number`

Number of segments to retrieve.
<ul><li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more segments (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more segments (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.segments.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->segments->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

segments = resend.Segments.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

segments = Resend::Segments.list
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	segments, err := client.Segments.ListWithContext(ctx)
	if err != nil {
		panic(err)
	}
	fmt.Println(segments)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _segments = resend.segments.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.segments.model.ListSegmentsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListSegmentsResponseSuccess response = resend.segments().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.SegmentListAsync();
Console.WriteLine( "Nr Segments={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/segments' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend segments list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      "name": "Registered Users",
      "created_at": "2026-10-06 22:59:55.977+00"
    }
  ]
}
```


# Update Segment
Source: https://resend.com/docs/api-reference/segments/update-segment

PATCH /segments/:segment_id
Update an existing segment.

## Path Parameters

The Segment ID.

## Body Parameters

**name** `string` *required*

The name of the segment.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.segments.update(
  '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  {
    name: 'Active Users',
  },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->segments->update('78261eea-8f8b-4381-83c6-79fa7120f1cf', [
  'name' => 'Active Users',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

params: resend.Segments.UpdateParams = {
    "name": "Active Users",
}

segment = resend.Segments.update('78261eea-8f8b-4381-83c6-79fa7120f1cf', params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  segment_id: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  name: "Active Users"
}
Resend::Segments.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.UpdateSegmentRequest{
		Name: "Active Users",
	}

	segment, err := client.Segments.UpdateWithContext(ctx, "78261eea-8f8b-4381-83c6-79fa7120f1cf", params)
	if err != nil {
		panic(err)
	}
	fmt.Println(segment)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _segment = resend
    .segments
    .update("78261eea-8f8b-4381-83c6-79fa7120f1cf", "Active Users")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.segments.model.UpdateSegmentOptions;
import com.resend.services.segments.model.UpdateSegmentResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateSegmentOptions options = UpdateSegmentOptions.builder()
            .name("Active Users")
            .build();

        UpdateSegmentResponseSuccess response = resend.segments().update("78261eea-8f8b-4381-83c6-79fa7120f1cf", options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.SegmentUpdateAsync( new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ), new SegmentData() {
  Name = "Active Users",
} );
Console.WriteLine( "Segment Id={0}", resp.Content.Id );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Active Users"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend segments update 78261eea-8f8b-4381-83c6-79fa7120f1cf --name "Active Users"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "segment",
  "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf"
}
```


# Add Batch Suppressions
Source: https://resend.com/docs/api-reference/suppressions/add-batch-suppressions

POST /suppressions/batch/add
Add up to 100 email addresses to the suppression list at once.

## Body Parameters

**emails** `array` *required*

The email addresses to suppress. Must contain between 1 and 100 email
addresses.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.suppressions.batch.add({
  emails: ['steve.wozniak@example.com', 'susan.kare@example.com'],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->suppressions->batch->add([
  'emails' => ['steve.wozniak@example.com', 'susan.kare@example.com'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Suppressions.Batch.AddParams = {
  "emails": ["steve.wozniak@example.com", "susan.kare@example.com"],
}

resend.Suppressions.Batch.add(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Suppressions::Batch.add(
  emails: ["steve.wozniak@example.com", "susan.kare@example.com"]
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.BatchAddSuppressionsRequest{
		Emails: []string{"steve.wozniak@example.com", "susan.kare@example.com"},
	}

	client.Suppressions.Batch.Add(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::BatchAddSuppressionOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts =
    BatchAddSuppressionOptions::from(vec!["steve.wozniak@example.com", "susan.kare@example.com"]);
  let _data = resend.suppressions.batch_add(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.suppressions.model.AddSuppressionsOptions;
import java.util.List;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        AddSuppressionsOptions options = AddSuppressionsOptions.builder()
                .emails(List.of("steve.wozniak@example.com", "susan.kare@example.com"))
                .build();

        resend.suppressions().batch().add(options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.SuppressionBatchAddAsync( new[]
{
    "steve.wozniak@example.com",
    "susan.kare@example.com",
} );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/suppressions/batch/add' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "emails": ["steve.wozniak@example.com", "susan.kare@example.com"]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend suppressions batch add --file suppressions.json
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "data": [
    {
      "object": "suppression",
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3"
    },
    {
      "object": "suppression",
      "id": "520784e2-887d-4c25-b53c-4ad46ad38100"
    }
  ]
}
```


# Add Suppression
Source: https://resend.com/docs/api-reference/suppressions/add-suppression

POST /suppressions
Add an email address to the suppression list.

## Body Parameters

**email** `string` *required*

The email address to suppress.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.suppressions.add({
  email: 'steve.wozniak@example.com',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->suppressions->add([
  'email' => 'steve.wozniak@example.com',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Suppressions.AddParams = {
  "email": "steve.wozniak@example.com",
}

resend.Suppressions.add(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Suppressions.add(email: "steve.wozniak@example.com")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.AddSuppressionRequest{
		Email: "steve.wozniak@example.com",
	}

	client.Suppressions.Add(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::AddSuppressionOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = AddSuppressionOptions::new().with_email("steve.wozniak@example.com");
  let _data = resend.suppressions.add(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.suppressions.model.AddSuppressionOptions;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        AddSuppressionOptions options = AddSuppressionOptions.builder()
                .email("steve.wozniak@example.com")
                .build();

        resend.suppressions().add(options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.SuppressionAddAsync( "steve.wozniak@example.com" );
Console.WriteLine( "Suppression Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/suppressions' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "email": "steve.wozniak@example.com"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend suppressions add steve.wozniak@example.com
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "suppression",
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3"
}
```


# Retrieve Suppression
Source: https://resend.com/docs/api-reference/suppressions/get-suppression

GET /suppressions/:suppression
Retrieve a single suppression by ID or email.

A suppression can be retrieved either by its ID or by the suppressed email
address.

## Path Parameters

**suppression** `email | id` *required*

The Suppression ID or email address.

The `source_id` in the response references the email that triggered the
suppression. For suppressions with a `manual` origin, `source_id` is `null`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.suppressions.get(
  'e169aa45-1ecf-4183-9955-b1499d5701d3', // or: 'steve.wozniak@example.com'
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Retrieve by suppression id
$resend->suppressions->get(
  'e169aa45-1ecf-4183-9955-b1499d5701d3'
);

// Retrieve by email
$resend->suppressions->get(
  'steve.wozniak@example.com'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Retrieve by suppression id
resend.Suppressions.get("e169aa45-1ecf-4183-9955-b1499d5701d3")

# Retrieve by email
resend.Suppressions.get("steve.wozniak@example.com")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Retrieve by suppression id
Resend::Suppressions.get("e169aa45-1ecf-4183-9955-b1499d5701d3")

# Retrieve by email
Resend::Suppressions.get("steve.wozniak@example.com")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Retrieve by suppression id
	client.Suppressions.Get("e169aa45-1ecf-4183-9955-b1499d5701d3")

	// Retrieve by email
	client.Suppressions.Get("steve.wozniak@example.com")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _data = resend
    .suppressions
    .get("e169aa45-1ecf-4183-9955-b1499d5701d3")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        // Retrieve by suppression id
        resend.suppressions().get("e169aa45-1ecf-4183-9955-b1499d5701d3");

        // Retrieve by email
        resend.suppressions().get("steve.wozniak@example.com");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

// Retrieve by suppression id
await resend.SuppressionRetrieveAsync( "e169aa45-1ecf-4183-9955-b1499d5701d3" );

// Retrieve by email
await resend.SuppressionRetrieveAsync( "steve.wozniak@example.com" );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Retrieve by suppression id
curl -X GET 'https://api.resend.com/suppressions/e169aa45-1ecf-4183-9955-b1499d5701d3' \
     -H 'Authorization: Bearer re_xxxxxxxxx'

# Retrieve by email
curl -X GET 'https://api.resend.com/suppressions/steve.wozniak@example.com' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Retrieve by suppression id
resend suppressions get e169aa45-1ecf-4183-9955-b1499d5701d3

# Retrieve by email
resend suppressions get steve.wozniak@example.com
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "suppression",
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "email": "steve.wozniak@example.com",
  "origin": "bounce",
  "source_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
  "created_at": "2026-10-06 23:47:56.678+00"
}
```


# List Suppressions
Source: https://resend.com/docs/api-reference/suppressions/list-suppressions

GET /suppressions
Show all suppressions.

## Query Parameters

**limit** `number`

Number of suppressions to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more suppressions (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more suppressions (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

**origin** `bounce | complaint | manual`

Filter suppressions by origin.

Possible values:

* `bounce`: emails suppressed automatically after a bounce
* `complaint`: emails suppressed due to a user complaint
* `manual`: emails suppressed by your team manually

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.suppressions.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->suppressions->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Suppressions.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Suppressions.list
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Suppressions.List(&resend.ListSuppressionsOptions{})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, list_opts::ListOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _data = resend.suppressions.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        resend.suppressions().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

await resend.SuppressionListAsync();
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/suppressions' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend suppressions list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "email": "steve.wozniak@example.com",
      "origin": "manual",
      "source_id": null,
      "created_at": "2026-10-06 23:47:56.678+00"
    },
    {
      "id": "520784e2-887d-4c25-b53c-4ad46ad38100",
      "email": "susan.kare@example.com",
      "origin": "bounce",
      "source_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "created_at": "2026-10-07 08:12:03.412+00"
    }
  ]
}

// The `source_id` in the response references the email that triggered the suppression. For suppressions with a `manual` origin, `source_id` is `null`.
```


# Remove Batch Suppressions
Source: https://resend.com/docs/api-reference/suppressions/remove-batch-suppressions

POST /suppressions/batch/remove
Remove up to 100 suppressions from the suppression list at once.

## Body Parameters

Provide either `emails` or `ids`, but not both.

**emails** `array`

The email addresses to remove from the suppression list. Must contain between
1 and 100 email addresses.

**ids** `array`

The suppression IDs to remove from the suppression list. Must contain between
1 and 100 IDs.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.suppressions.batch.remove({
  ids: ['e169aa45-1ecf-4183-9955-b1499d5701d3'],
  // or: emails: ['steve.wozniak@example.com', 'susan.kare@example.com'],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Remove by suppression ids
$resend->suppressions->batch->remove([
  'ids' => ['e169aa45-1ecf-4183-9955-b1499d5701d3'],
]);

// Remove by emails
$resend->suppressions->batch->remove([
  'emails' => ['steve.wozniak@example.com', 'susan.kare@example.com'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Remove by suppression ids
ids_params: resend.Suppressions.Batch.RemoveParams = {
  "ids": ["e169aa45-1ecf-4183-9955-b1499d5701d3"],
}

resend.Suppressions.Batch.remove(ids_params)

# Remove by emails
emails_params: resend.Suppressions.Batch.RemoveParams = {
  "emails": ["steve.wozniak@example.com", "susan.kare@example.com"],
}

resend.Suppressions.Batch.remove(emails_params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Remove by suppression ids
Resend::Suppressions::Batch.remove(
  ids: ["e169aa45-1ecf-4183-9955-b1499d5701d3"]
)

# Remove by emails
Resend::Suppressions::Batch.remove(
  emails: ["steve.wozniak@example.com", "susan.kare@example.com"]
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Remove by suppression ids
	client.Suppressions.Batch.Remove(&resend.BatchRemoveSuppressionsRequest{
		Ids: []string{"e169aa45-1ecf-4183-9955-b1499d5701d3"},
	})

	// Remove by emails
	client.Suppressions.Batch.Remove(&resend.BatchRemoveSuppressionsRequest{
		Emails: []string{"steve.wozniak@example.com", "susan.kare@example.com"},
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result, types::BatchRemoveSuppressionOptions};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  // Remove by email
  let opt_emails = BatchRemoveSuppressionOptions::new()
    .add_emails(vec!["steve.wozniak@example.com", "susan.kare@example.com"]);
  let _data = resend.suppressions.batch_remove(opt_emails).await?;

  // Remove by id
  let opt_ids =
    BatchRemoveSuppressionOptions::new().add_ids(vec!["e169aa45-1ecf-4183-9955-b1499d5701d3"]);

  let _data = resend.suppressions.batch_remove(opt_ids).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.suppressions.model.RemoveSuppressionsOptions;
import java.util.List;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        // Remove by suppression ids
        RemoveSuppressionsOptions byIds = RemoveSuppressionsOptions.builder()
                .ids(List.of("e169aa45-1ecf-4183-9955-b1499d5701d3"))
                .build();

        resend.suppressions().batch().remove(byIds);

        // Remove by emails
        RemoveSuppressionsOptions byEmails = RemoveSuppressionsOptions.builder()
                .emails(List.of("steve.wozniak@example.com", "susan.kare@example.com"))
                .build();

        resend.suppressions().batch().remove(byEmails);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

// Remove by suppression ids
await resend.SuppressionBatchRemoveAsync( new[]
{
    new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
} );

// Remove by emails
await resend.SuppressionBatchRemoveAsync( new[]
{
    "steve.wozniak@example.com",
    "susan.kare@example.com",
} );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Remove by suppression ids
curl -X POST 'https://api.resend.com/suppressions/batch/remove' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "ids": ["e169aa45-1ecf-4183-9955-b1499d5701d3"]
}'

# Remove by emails
curl -X POST 'https://api.resend.com/suppressions/batch/remove' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "emails": ["steve.wozniak@example.com", "susan.kare@example.com"]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Remove by email
resend suppressions batch remove --file suppressions.json

# Remove by id
resend suppressions batch remove --file suppression-ids.json --ids
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "data": [
    {
      "object": "suppression",
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "deleted": true
    }
  ]
}
```


# Remove Suppression
Source: https://resend.com/docs/api-reference/suppressions/remove-suppression

DELETE /suppressions/:suppression
Remove a single suppression by ID or email.

## Path Parameters

**suppression** `email | id` *required*

The Suppression ID or email address.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.suppressions.remove(
  'e169aa45-1ecf-4183-9955-b1499d5701d3', // or: 'steve.wozniak@example.com'
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Remove by suppression id
$resend->suppressions->remove(
  'e169aa45-1ecf-4183-9955-b1499d5701d3'
);

// Remove by email
$resend->suppressions->remove(
  'steve.wozniak@example.com'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Remove by suppression id
resend.Suppressions.remove("e169aa45-1ecf-4183-9955-b1499d5701d3")

# Remove by email
resend.Suppressions.remove("steve.wozniak@example.com")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Remove by suppression id
Resend::Suppressions.remove("e169aa45-1ecf-4183-9955-b1499d5701d3")

# Remove by email
Resend::Suppressions.remove("steve.wozniak@example.com")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Remove by suppression id
	client.Suppressions.Remove("e169aa45-1ecf-4183-9955-b1499d5701d3")

	// Remove by email
	client.Suppressions.Remove("steve.wozniak@example.com")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  // Remove by suppression id
  let _data = resend
    .suppressions
    .remove("e169aa45-1ecf-4183-9955-b1499d5701d3")
    .await?;

  // Remove by email
  let _data = resend
    .suppressions
    .remove("steve.wozniak@example.com")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        // Remove by suppression id
        resend.suppressions().remove("e169aa45-1ecf-4183-9955-b1499d5701d3");

        // Remove by email
        resend.suppressions().remove("steve.wozniak@example.com");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

// Remove by suppression id
await resend.SuppressionRemoveAsync( "e169aa45-1ecf-4183-9955-b1499d5701d3" );

// Remove by email
await resend.SuppressionRemoveAsync( "steve.wozniak@example.com" );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Remove by suppression id
curl -X DELETE 'https://api.resend.com/suppressions/e169aa45-1ecf-4183-9955-b1499d5701d3' \
     -H 'Authorization: Bearer re_xxxxxxxxx'

# Remove by email
curl -X DELETE 'https://api.resend.com/suppressions/steve.wozniak@example.com' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Remove by suppression id
resend suppressions delete e169aa45-1ecf-4183-9955-b1499d5701d3

# Remove by email
resend suppressions delete steve.wozniak@example.com
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "suppression",
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "deleted": true
}
```


# Create Template
Source: https://resend.com/docs/api-reference/templates/create-template

POST /templates
Create a new template with optional variables.

## Body Parameters

**name** `string` *required*

The name of the template.

**html** `string` *required*

The HTML version of the template.

**alias** `string`

The alias of the template.

**from** `string`

Sender email address.

To include a friendly name, use the format `"Your Name <sender@domain.com>"`.

If provided, this value can be overridden when sending an email using the template.

**subject** `string`

Default email subject.

This value can be overridden when sending an email using the template.

Default Reply-to email address. For multiple addresses, send as an array of strings.

This value can be overridden when sending an email using the template.

**text** `string`

The plain text version of the message.

> [!NOTE]
>
> If not provided, the HTML will be used to generate a plain text version. You can opt out of this behavior by setting value to an empty string.

**react** `React.ReactNode`

The React component used to write the template. *Only available in the Node.js
SDK.*

**variables** `array`

The array of variables used in the template. Each template may contain up to 50 variables.

Each variable is an object with the following properties:

**properties**

**key** `string` *required*

The key of the variable. We recommend capitalizing the key (e.g. `PRODUCT_NAME`). The following variable names are reserved and cannot be used:
`FIRST_NAME`, `LAST_NAME`, `EMAIL`, `RESEND_UNSUBSCRIBE_URL`, `contact`, and `this`.

**type** `'string' | 'number'` *required*

The type of the variable.

Can be `'string'` or `'number'`

The fallback value of the variable. The value must match the type of the variable.

If no fallback value is provided, you must provide a value for the variable when sending an email using the template.

> [!NOTE]
>
> Before you can use a template, you must publish it first. To publish a
> template, use the [Templates dashboard](https://resend.com/templates) or
> [publish template API](/docs/api-reference/templates/publish-template).
>
> [Learn more about Templates](/docs/dashboard/templates/introduction).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.templates.create({
  name: 'order-confirmation',
  html: '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
  variables: [
    {
      key: 'PRODUCT',
      type: 'string',
      fallbackValue: 'item',
    },
    {
      key: 'PRICE',
      type: 'number',
      fallbackValue: 25,
    },
  ],
});

// Or create and publish a template in one step
const { data: published, error: publishError } = await resend.templates
  .create({
    name: 'order-confirmation',
    html: '<p>Thanks for your order!</p>',
  })
  .publish();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->templates->create([
  'name' => 'order-confirmation',
  'html' => '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
  'variables' => [
    [
      'key' => 'PRODUCT',
      'type' => 'string',
      'fallback_value' => 'item',
    ],
    [
      'key' => 'PRICE',
      'type' => 'number',
      'fallback_value' => 25,
    ]
  ],
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Templates.create({
    "name": "order-confirmation",
    "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    "variables": [
        {
            "key": "PRODUCT",
            "type": "string",
            "fallback_value": "item",
        },
        {
            "key": "PRICE",
            "type": "number",
            "fallback_value": 25,
        }
    ],
})
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Templates.create(
  name: "order-confirmation",
  html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  variables: [
    {
      key: "PRODUCT",
      type: "string",
      fallback_value: "item"
    },
    {
      key: "PRICE",
      type: "number",
      fallback_value: 25
    }
  ]
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Templates.CreateWithContext(context.TODO(), &resend.CreateTemplateRequest{
		Name: "order-confirmation",
		Html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
		Variables: []*resend.TemplateVariable{
			{
				Key:           "PRODUCT",
				Type:          resend.VariableTypeString,
				FallbackValue: "item",
			},
			{
				Key:           "PRICE",
				Type:          resend.VariableTypeNumber,
				FallbackValue: 25,
			},
		},
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateTemplateOptions, Variable, VariableType},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let name = "order-confirmation";
  let html = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>";

  let variables = [
    Variable::new("PRODUCT", VariableType::String).with_fallback("item"),
    Variable::new("PRICE", VariableType::Number).with_fallback(25)
  ];

  let opts = CreateTemplateOptions::new(name, html).with_variables(&variables);
  let template = resend.templates.create(opts).await?;

  let _published = resend.templates.publish(&template.id).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.templates.model.CreateTemplateOptions;
import com.resend.services.templates.model.CreateTemplateResponseSuccess;
import com.resend.services.templates.model.Variable;
import com.resend.services.templates.model.VariableType;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateTemplateOptions params = CreateTemplateOptions.builder()
                .name("order-confirmation")
                .html("<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>")
                .addVariable(new Variable("PRODUCT", VariableType.STRING, "item"))
                .addVariable(new Variable("PRICE", VariableType.NUMBER, 25))
                .build();

        CreateTemplateResponseSuccess data = resend.templates().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create("re_xxxxxxxxx");

var variables = new List<TemplateVariable>()
{
  new TemplateVariable() {
    Key = "PRODUCT",
    Type = TemplateVariableType.String,
    Default = "item",
  },
  new TemplateVariable() {
    Key = "PRICE",
    Type = TemplateVariableType.Number,
    Default = 25,
  }
};

var resp = await resend.TemplateCreateAsync(
  new TemplateData()
  {
    Name = "welcome-email",
    HtmlBody = "<strong>Hey, {{{PRODUCT}}}, you are {{{PRICE}}} years old.</strong>",
    Variables = variables,
  }
);

Console.WriteLine($"Template Id={resp.Content}");
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/templates' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "order-confirmation",
  "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  "variables": [
    {
      "key": "PRODUCT",
      "type": "string",
      "fallback_value": "item"
    },
    {
      "key": "PRICE",
      "type": "number",
      "fallback_value": 25
    }
  ]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend templates create \
  --name order-confirmation \
  --html "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>" \
  --var PRODUCT:string:item \
  --var PRICE:number:25
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  "object": "template"
}
```


# Delete Template
Source: https://resend.com/docs/api-reference/templates/delete-template

DELETE /templates/:template_id
Delete a template.

## Path Parameters

**id | alias** `string`

The ID or alias of the template to delete.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.templates.remove(
  '34a080c9-b17d-4187-ad80-5af20266e535',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->templates->remove('34a080c9-b17d-4187-ad80-5af20266e535');
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Templates.remove("34a080c9-b17d-4187-ad80-5af20266e535")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Templates.remove("34a080c9-b17d-4187-ad80-5af20266e535")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Templates.RemoveWithContext(
		context.TODO(),
		"34a080c9-b17d-4187-ad80-5af20266e535",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .templates
    .delete("34a080c9-b17d-4187-ad80-5af20266e535")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.templates.model.DeleteTemplateResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        DeleteTemplateResponseSuccess data = resend.templates().remove("34a080c9-b17d-4187-ad80-5af20266e535");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.TemplateDeleteAsync( new Guid( "34a080c9-b17d-4187-ad80-5af20266e535" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend templates delete 34a080c9-b17d-4187-ad80-5af20266e535
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "template",
  "id": "34a080c9-b17d-4187-ad80-5af20266e535",
  "deleted": true
}
```


# Duplicate Template
Source: https://resend.com/docs/api-reference/templates/duplicate-template

POST /templates/:template_id/duplicate
Duplicate a template.

## Path Parameters

**id | alias** `string`

The ID or alias of the template to duplicate.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.templates.duplicate(
  '34a080c9-b17d-4187-ad80-5af20266e535',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->templates->duplicate('34a080c9-b17d-4187-ad80-5af20266e535');
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Templates.duplicate("34a080c9-b17d-4187-ad80-5af20266e535")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Templates.duplicate("34a080c9-b17d-4187-ad80-5af20266e535")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Templates.DuplicateWithContext(
		context.TODO(),
		"34a080c9-b17d-4187-ad80-5af20266e535",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _duplicated = resend
    .templates
    .duplicate("34a080c9-b17d-4187-ad80-5af20266e535")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.templates.model.DuplicateTemplateResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        DuplicateTemplateResponseSuccess data = resend.templates().duplicate("34a080c9-b17d-4187-ad80-5af20266e535");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.TemplateDuplicateAsync( new Guid( "34a080c9-b17d-4187-ad80-5af20266e535" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535/duplicate' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend templates duplicate 34a080c9-b17d-4187-ad80-5af20266e535
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "template",
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3"
}
```


# Retrieve Template
Source: https://resend.com/docs/api-reference/templates/get-template

GET /templates/:template_id
Retrieve a template by ID.

## Path Parameters

**id | alias** `string`

The ID or alias of the template to retrieve.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.templates.get(
  '34a080c9-b17d-4187-ad80-5af20266e535',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->templates->get('34a080c9-b17d-4187-ad80-5af20266e535');
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Templates.get("34a080c9-b17d-4187-ad80-5af20266e535")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Templates.get("34a080c9-b17d-4187-ad80-5af20266e535")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Templates.GetWithContext(
		context.TODO(),
		"34a080c9-b17d-4187-ad80-5af20266e535",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _template = resend
    .templates
    .get("34a080c9-b17d-4187-ad80-5af20266e535")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.templates.model.GetTemplateResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetTemplateResponseSuccess data = resend.templates().get("34a080c9-b17d-4187-ad80-5af20266e535");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var res = await resend.TemplateRetrieveAsync( new Guid( "34a080c9-b17d-4187-ad80-5af20266e535" ) );
Console.WriteLine( "Template Name={0}", res.Content.Name );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend templates get 34a080c9-b17d-4187-ad80-5af20266e535
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "template",
  "id": "34a080c9-b17d-4187-ad80-5af20266e535",
  "current_version_id": "b2693018-7abb-4b4b-b4cb-aadf72dc06bd",
  "alias": "reset-password",
  "name": "reset-password",
  "created_at": "2026-10-06 23:47:56.678+00",
  "updated_at": "2026-10-06 23:47:56.678+00",
  "status": "published",
  "published_at": "2026-10-06 23:47:56.678+00",
  "from": "John Doe <john.doe@example.com>",
  "subject": "Hello, world!",
  "reply_to": null,
  "html": "<h1>Hello, world!</h1>",
  "text": "Hello, world!",
  "variables": [
    {
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "key": "user_name",
      "type": "string",
      "fallback_value": "John Doe",
      "created_at": "2026-10-06 23:47:56.678+00",
      "updated_at": "2026-10-06 23:47:56.678+00"
    }
  ],
  "has_unpublished_versions": true
}
```


# List Templates
Source: https://resend.com/docs/api-reference/templates/list-templates

GET /templates
List all templates.

By default, the API will return the most recent 20 templates. You can optionally use the `limit` parameter to return a different number of templates or control the pagination of the results with the `after` or `before` parameters.

## Query Parameters

**limit** `number`

Number of templates to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more templates (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more templates (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.templates.list({
  limit: 2,
  after: '34a080c9-b17d-4187-ad80-5af20266e535',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->templates->list([
  'limit' => 2,
  'after' => '34a080c9-b17d-4187-ad80-5af20266e535'
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Templates.list({
    "limit": 2,
    "after": "34a080c9-b17d-4187-ad80-5af20266e535",
})
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Templates.list(
  limit: 2,
  after: "34a080c9-b17d-4187-ad80-5af20266e535"
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	limit := 2
	after := "34a080c9-b17d-4187-ad80-5af20266e535"

	client.Templates.ListWithContext(context.TODO(), &resend.ListOptions{
		Limit: &limit,
		After: &after,
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let list_opts = ListOptions::default()
    .with_limit(2)
    .list_after("34a080c9-b17d-4187-ad80-5af20266e535");

  let _list = resend.templates.list(list_opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.core.net.ListParams;
import com.resend.services.templates.model.ListTemplatesResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListParams params = ListParams.builder()
            .limit(2)
            .after("34a080c9-b17d-4187-ad80-5af20266e535")
            .build();

        ListTemplatesResponseSuccess data = resend.templates().list(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.TemplateListAsync();
Console.WriteLine( "Nr Templates={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/templates?limit=2&after=34a080c9-b17d-4187-ad80-5af20266e535' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend templates list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "data": [
    {
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "name": "reset-password",
      "status": "draft",
      "published_at": null,
      "created_at": "2026-10-06 23:47:56.678+00",
      "updated_at": "2026-10-06 23:47:56.678+00",
      "alias": "reset-password"
    },
    {
      "id": "b7f9c2e1-1234-4abc-9def-567890abcdef",
      "name": "welcome-message",
      "status": "published",
      "published_at": "2026-10-06 23:47:56.678+00",
      "created_at": "2026-10-06 23:47:56.678+00",
      "updated_at": "2026-10-06 23:47:56.678+00",
      "alias": "welcome-message"
    }
  ],
  "has_more": false
}
```


# Publish Template
Source: https://resend.com/docs/api-reference/templates/publish-template

POST /templates/:template_id/publish
Publish a template.

## Path Parameters

**id | alias** `string`

The ID or alias of the template to publish.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.templates.publish(
  '34a080c9-b17d-4187-ad80-5af20266e535',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->templates->publish('34a080c9-b17d-4187-ad80-5af20266e535');
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Templates.publish("34a080c9-b17d-4187-ad80-5af20266e535")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Templates.publish("34a080c9-b17d-4187-ad80-5af20266e535")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Templates.PublishWithContext(
		context.TODO(),
		"34a080c9-b17d-4187-ad80-5af20266e535",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _published = resend
    .templates
    .publish("34a080c9-b17d-4187-ad80-5af20266e535")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.templates.model.PublishTemplateResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        PublishTemplateResponseSuccess data = resend.templates().publish("34a080c9-b17d-4187-ad80-5af20266e535");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.TemplatePublishAsync( new Guid( "34a080c9-b17d-4187-ad80-5af20266e535" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535/publish' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend templates publish 34a080c9-b17d-4187-ad80-5af20266e535
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "template",
  "id": "34a080c9-b17d-4187-ad80-5af20266e535"
}
```


# Update Template
Source: https://resend.com/docs/api-reference/templates/update-template

PATCH /templates/:template_id
Update a template.

## Path Parameters

**id | alias** `string`

The ID or alias of the template to duplicate.

## Body Parameters

**name** `string`

The name of the template.

**html** `string`

The HTML version of the template.

**alias** `string`

The alias of the template.

**from** `string`

Sender email address.

To include a friendly name, use the format `"Your Name <sender@domain.com>"`.

If provided, this value can be overridden when sending an email using the template.

**subject** `string`

Default email subject.

This value can be overridden when sending an email using the template.

Default Reply-to email address. For multiple addresses, send as an array of strings.

This value can be overridden when sending an email using the template.

**text** `string`

The plain text version of the message.

> [!NOTE]
>
> If not provided, the HTML will be used to generate a plain text version. You can opt out of this behavior by setting value to an empty string.

**react** `React.ReactNode`

The React component used to write the template. *Only available in the Node.js
SDK.*

**variables** `array`

The array of variables used in the template. Each template may contain up to 50 variables.

Each variable is an object with the following properties:

**properties**

**key** `string` *required*

The key of the variable. We recommend capitalizing the key (e.g. `PRODUCT_NAME`). The following variable names are reserved and cannot be used:
`FIRST_NAME`, `LAST_NAME`, `EMAIL`, `RESEND_UNSUBSCRIBE_URL`, `contact`, and `this`.

**type** `'string' | 'number'` *required*

The type of the variable.

Can be `'string'` or `'number'`

The fallback value of the variable. The value must match the type of the variable.

If no fallback value is provided, you must provide a value for the variable when sending an email using the template.

> [!NOTE]
>
> Before you can use a template, you must publish it first. To publish a
> template, use the [Templates dashboard](https://resend.com/templates) or
> [publish template API](/docs/api-reference/templates/publish-template).
>
> [Learn more about Templates](/docs/dashboard/templates/introduction).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.templates.update(
  '34a080c9-b17d-4187-ad80-5af20266e535',
  {
    name: 'order-confirmation',
    html: '<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>',
  },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->templates->update('34a080c9-b17d-4187-ad80-5af20266e535', [
  'name' => 'order-confirmation',
  'html' => '<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>',
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Templates.update({
    "id": "34a080c9-b17d-4187-ad80-5af20266e535",
    "name": "order-confirmation",
    "html": "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>",
})
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Templates.update("34a080c9-b17d-4187-ad80-5af20266e535", {
  name: "order-confirmation",
  html: "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>"
})
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Templates.UpdateWithContext(context.TODO(), "34a080c9-b17d-4187-ad80-5af20266e535", &resend.UpdateTemplateRequest{
		Name: "order-confirmation",
		Html: "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>",
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::UpdateTemplateOptions,
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let name = "order-confirmation";
  let html = "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>";

  let update = UpdateTemplateOptions::new(name, html);

  let _template = resend
    .templates
    .update("34a080c9-b17d-4187-ad80-5af20266e535", update)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.templates.model.UpdateTemplateOptions;
import com.resend.services.templates.model.UpdateTemplateResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateTemplateOptions params = UpdateTemplateOptions.builder()
                .name("order-confirmation")
                .html("<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>")
                .build();

        UpdateTemplateResponseSuccess data = resend.templates().update("34a080c9-b17d-4187-ad80-5af20266e535", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.TemplateUpdateAsync(
    templateId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
    new TemplateData()
    {
        HtmlBody = "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "order-confirmation",
  "html": "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend templates update 34a080c9-b17d-4187-ad80-5af20266e535 \
  --name order-confirmation \
  --html "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "template",
  "id": "34a080c9-b17d-4187-ad80-5af20266e535"
}
```


# Create Topic
Source: https://resend.com/docs/api-reference/topics/create-topic

POST /topics
Create and email topics to segment your audience.

## Body Parameters

**name** `string` *required*

The topic name. Max length is `50` characters.

The default subscription preference for new contacts. Possible values:
`opt_in` or `opt_out`.

> [!NOTE]
>
> This value cannot be changed later.

**description** `string`

The topic description. Max length is `200` characters.

The visibility of the topic on the unsubscribe page. Possible values: `public` or `private`.

* `private`: only contacts who are opted in to the topic can see it on the unsubscribe page.
* `public`: all contacts can see the topic on the unsubscribe page.

If not specified, defaults to `private`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.topics.create({
  name: 'Weekly Newsletter',
  defaultSubscription: 'opt_in',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->topics->create([
  'name' => 'Weekly Newsletter',
  'default_subscription' => 'opt_in',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Topics.create({
    "name": "Weekly Newsletter",
    "default_subscription": "opt_in",
    "description": "Subscribe to our weekly newsletter for updates",
})
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Topics.create(
  name: "Weekly Newsletter",
  default_subscription: "opt_in"
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Topics.CreateWithContext(context.TODO(), &resend.CreateTopicRequest{
		Name:                "Weekly Newsletter",
		DefaultSubscription: resend.DefaultSubscriptionOptIn,
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateTopicOptions, SubscriptionType},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = CreateTopicOptions::new("Weekly Newsletter", SubscriptionType::OptIn);
  let _topic = resend.topics.create(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.topics.model.CreateTopicOptions;
import com.resend.services.topics.model.CreateTopicResponseSuccess;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    CreateTopicOptions createTopicOptions = CreateTopicOptions.builder()
      .name("Weekly Newsletter")
      .defaultSubscription("opt_in")
      .build();

    CreateTopicResponseSuccess response = resend.topics().create(createTopicOptions);
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.TopicCreateAsync( new TopicData() {
  Name = "Weekly Newsletter",
  Description = "Weekly newsletter for our subscribers",
  SubscriptionDefault = SubscriptionType.OptIn,
} );
Console.WriteLine( "Topic Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/topics' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Weekly Newsletter",
  "default_subscription": "opt_in"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend topics create --name "Weekly Newsletter" --default-subscription opt_in
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "topic",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
}
```


# Delete Topic
Source: https://resend.com/docs/api-reference/topics/delete-topic

DELETE /topics/:topic_id
Remove an existing topic.

## Path Parameters

The topic ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.topics.remove(
  'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->topics->remove('b6d24b8e-af0b-4c3c-be0c-359bbd97381e');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Topics.remove(id="b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Topics.remove("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Topics.RemoveWithContext(
		context.TODO(),
		"b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend.topics.delete("delete").await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.topics.model.RemoveTopicResponseSuccess;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    RemoveTopicResponseSuccess response = resend.topics().remove("b6d24b8e-af0b-4c3c-be0c-359bbd97381e");
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.TopicDeleteAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/topics/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend topics delete b6d24b8e-af0b-4c3c-be0c-359bbd97381e
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "topic",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  "deleted": true
}
```


# Retrieve Topic
Source: https://resend.com/docs/api-reference/topics/get-topic

GET /topics/:topic_id
Retrieve a topic by its ID.

## Path Parameters

The Topic ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.topics.get(
  'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->topics->get('b6d24b8e-af0b-4c3c-be0c-359bbd97381e');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Topics.get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Topics.get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Topics.GetWithContext(
		context.TODO(),
		"b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _topic = resend
    .topics
    .get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.topics.model.GetTopicResponseSuccess;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    GetTopicResponseSuccess topic = resend.topics().get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e");
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.TopicRetrieveAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
Console.WriteLine( "Topic Id={0}", resp.Content.Id );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/topics/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend topics get b6d24b8e-af0b-4c3c-be0c-359bbd97381e
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "topic",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  "name": "Weekly Newsletter",
  "description": "Weekly newsletter for our subscribers",
  "default_subscription": "opt_in",
  "visibility": "public",
  "created_at": "2026-04-08 00:11:13.110779+00"
}
```


# List Topics
Source: https://resend.com/docs/api-reference/topics/list-topics

GET /topics
Retrieve a list of topics for the authenticated user.

## Query Parameters

**limit** `number`

Number of topics to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more topics (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more topics (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.topics.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->topics->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Topics.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Topics.list()
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Topics.ListWithContext(context.TODO(), nil)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _list = resend.topics.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.topics.model.ListTopicsResponseSuccess;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    ListTopicsResponseSuccess response = resend.topics().list();
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.TopicListAsync();
Console.WriteLine( "Nr Topics={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/topics' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend topics list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
      "name": "Weekly Newsletter",
      "description": "Weekly newsletter for our subscribers",
      "default_subscription": "opt_in",
      "visibility": "public",
      "created_at": "2026-04-08 00:11:13.110779+00"
    }
  ]
}
```


# Update Topic
Source: https://resend.com/docs/api-reference/topics/update-topic

PATCH /topics/:topic_id
Update an existing topic.

## Path Parameters

The Topic ID.

## Body Parameters

**name** `string`

The topic name. Max length is `50` characters.

**description** `string`

The topic description. Max length is `200` characters.

The visibility of the topic on the unsubscribe page. Possible values: `public` or `private`.

* `private`: only contacts who are opted in to the topic can see it on the unsubscribe page.
* `public`: all contacts can see the topic on the unsubscribe page.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.topics.update({
  id: 'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
  name: 'Weekly Newsletter',
  description: 'Weekly newsletter for our subscribers',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->topics->update('b6d24b8e-af0b-4c3c-be0c-359bbd97381e', [
  'name' => 'Weekly Newsletter',
  'description' => 'Weekly newsletter for our subscribers',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Topics.update(
    id="b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    params={
        "name": "Weekly Newsletter",
        "description": "Weekly newsletter for our subscribers",
    }
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Topics.update(
  topic_id: "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  name: "Weekly Newsletter",
  description: "Weekly newsletter for our subscribers"
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Topics.UpdateWithContext(context.TODO(), "b6d24b8e-af0b-4c3c-be0c-359bbd97381e", &resend.UpdateTopicRequest{
		Name:        "Weekly Newsletter",
		Description: "Weekly newsletter for our subscribers",
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::UpdateTopicOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let update = UpdateTopicOptions::new()
    .with_name("Weekly Newsletter")
    .with_description("Weekly newsletter for our subscribers");

  let _topic = resend
    .topics
    .update("b6d24b8e-af0b-4c3c-be0c-359bbd97381e", update)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.topics.model.UpdateTopicOptions;
import com.resend.services.topics.model.UpdateTopicResponseSuccess;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    UpdateTopicOptions updateTopicOptions = UpdateTopicOptions.builder()
      .name("Weekly Newsletter")
      .description("Weekly newsletter for our subscribers")
      .build();

    UpdateTopicResponseSuccess response = resend.topics().update(
      "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
      updateTopicOptions
    );
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.TopicUpdateAsync(
  new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ),
  new TopicData() {
    Name = "Weekly Newsletter",
    Description = "Weekly newsletter for our subscribers",
  }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/topics/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Weekly Newsletter",
  "description": "Weekly newsletter for our subscribers"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend topics update b6d24b8e-af0b-4c3c-be0c-359bbd97381e \
  --name "Weekly Newsletter" \
  --description "Weekly newsletter for our subscribers"
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "topic",
  "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
}
```


# Create Webhook
Source: https://resend.com/docs/api-reference/webhooks/create-webhook

POST /webhooks
Create a webhook to receive real-time notifications about email events.

## Body Parameters

**endpoint** `string` *required*

The URL where webhook events will be sent.

**events** `string[]` *required*

Array of event types to subscribe to.

See [event types](/docs/webhooks/event-types) for available options.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.create({
  endpoint: 'https://example.com/handler',
  events: ['email.sent'],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->webhooks->create([
  'endpoint' => 'https://example.com/handler',
  'events' => ['email.sent'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

params: resend.Webhooks.CreateParams = {
    "endpoint": "https://example.com/handler",
    "events": ["email.sent"],
}

webhook = resend.Webhooks.create(params=params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

params = {
  endpoint: 'https://example.com/handler',
  events: ['email.sent']
}

webhook = Resend::Webhooks.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateWebhookRequest{
		Endpoint: "https://example.com/handler",
		Events:   []string{"email.sent"},
	}

	client.Webhooks.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  events::EmailEventType::{EmailSent},
  types::CreateWebhookOptions,
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let events = [EmailSent];
  let opts = CreateWebhookOptions::new("https://example.com/handler", events);
  let _webhook = resend.webhooks.create(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.CreateWebhookOptions;
import com.resend.services.webhooks.model.CreateWebhookResponseSuccess;
import static com.resend.services.webhooks.model.WebhookEvent.*;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateWebhookOptions options = CreateWebhookOptions.builder()
              .endpoint("https://example.com/handler")
              .events(EMAIL_SENT)
              .build();

        CreateWebhookResponseSuccess response = resend.webhooks().create(options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var data = new WebhookData()
{
    EndpointUrl = "https://example.com/handler",
    Events = [ WebhookEventType.EmailSent ],
    Status = WebhookStatus.Disabled,
};

var resp = await resend.WebhookCreateAsync( data );
Console.WriteLine( "Webhook Id={0}", resp.Content.Id );
Console.WriteLine( "Signing secret={0}", resp.Content.SigningSecret );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/webhooks' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "endpoint": "https://example.com/handler",
  "events": ["email.sent"]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks create \
  --endpoint https://example.com/handler \
  --events email.sent
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "webhook",
  "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
  "signing_secret": "whsec_xxxxxxxxxx"
}
```


# Delete Webhook
Source: https://resend.com/docs/api-reference/webhooks/delete-webhook

DELETE /webhooks/:webhook_id
Remove an existing webhook.

## Path Parameters

The Webhook ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.remove(
  '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->webhooks->remove('4dd369bc-aa82-4ff3-97de-514ae3000ee0');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

webhook = resend.Webhooks.remove(webhook_id='4dd369bc-aa82-4ff3-97de-514ae3000ee0')
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

webhook = Resend::Webhooks.remove('4dd369bc-aa82-4ff3-97de-514ae3000ee0')
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Webhooks.Remove("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .webhooks
    .delete("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.RemoveWebhookResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveWebhookResponseSuccess response = resend.webhooks().remove("4dd369bc-aa82-4ff3-97de-514ae3000ee0");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.WebhookDeleteAsync( new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/webhooks/4dd369bc-aa82-4ff3-97de-514ae3000ee0' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks delete 4dd369bc-aa82-4ff3-97de-514ae3000ee0
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "webhook",
  "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
  "deleted": true
}
```


# Retrieve Event
Source: https://resend.com/docs/api-reference/webhooks/get-event

GET /webhooks/:webhook_id/events/:event_id
Retrieve the details of a single event delivered to a webhook.

## Path Parameters

The Webhook ID.

The Webhook Event ID.

## Response Fields

**object** `string`

Always `webhook_event`.

**id** `string`

The event ID.

**type** `string`

The event type, for example `email.sent`.

**created\_at** `string`

When the event was created.

**status** `string`

Delivery status of the event to this webhook: `success`, `failed`,
`attempting`, or `pending`.

**next\_attempt\_at** `string | null`

When the next delivery attempt is scheduled. `null` once the event reaches
`success` or `failed`.

**payload** `object`

The event payload that was sent to your endpoint.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.events.get({
  eventId: 'msg_1srOrx2ZWZBpBUvZwXKQmoEYga2',
  webhookId: '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$event = $resend->webhooks->events->get(
    '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
    'msg_1srOrx2ZWZBpBUvZwXKQmoEYga2'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

event = resend.Webhooks.get_event(
    webhook_id='4dd369bc-aa82-4ff3-97de-514ae3000ee0',
    event_id='msg_1srOrx2ZWZBpBUvZwXKQmoEYga2',
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

event = Resend::Webhooks.get_event(
  '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
  'msg_1srOrx2ZWZBpBUvZwXKQmoEYga2'
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Webhooks.GetEvent(
		"4dd369bc-aa82-4ff3-97de-514ae3000ee0",
		"msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _event = resend
    .webhooks
    .get_event(
      "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
      "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.GetWebhookEventResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetWebhookEventResponseSuccess event = resend.webhooks().getEvent(
            "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
            "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2"
        );
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.WebhookEventRetrieveAsync(
    new Guid( "4dd369bc-aa82-4ff3-97de-514ae3000ee0" ),
    "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2"
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/webhooks/4dd369bc-aa82-4ff3-97de-514ae3000ee0/events/msg_1srOrx2ZWZBpBUvZwXKQmoEYga2' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "webhook_event",
  "id": "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
  "type": "email.sent",
  "created_at": "2026-08-22T15:28:00.000Z",
  "status": "attempting",
  "next_attempt_at": "2026-08-22T15:33:00.000Z",
  "payload": {
    "type": "email.sent",
    "created_at": "2026-08-22T15:28:00.000Z",
    "data": {
      "email_id": "571f1f42-1c2d-4b1f-8f8e-8b3b5b3b5b3b",
      "from": "onboarding@resend.dev",
      "to": ["delivered@resend.dev"],
      "subject": "Welcome",
      "created_at": "2026-08-22T15:27:59.000Z"
    }
  }
}
```


# Retrieve Webhook
Source: https://resend.com/docs/api-reference/webhooks/get-webhook

GET /webhooks/:webhook_id
Retrieve a single webhook for the authenticated user.

## Path Parameters

The Webhook ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.get(
  '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->webhooks->get('4dd369bc-aa82-4ff3-97de-514ae3000ee0');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

webhook = resend.Webhooks.get(webhook_id='4dd369bc-aa82-4ff3-97de-514ae3000ee0')
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

webhook = Resend::Webhooks.get('4dd369bc-aa82-4ff3-97de-514ae3000ee0')
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Webhooks.Get("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _webhook = resend
    .webhooks
    .get("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.GetWebhookResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetWebhookResponseSuccess webhook = resend.webhooks().get("4dd369bc-aa82-4ff3-97de-514ae3000ee0");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.WebhookRetrieveAsync( new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ) );
Console.WriteLine( "Endpoint={0}", resp.Content.EndpointUrl );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/webhooks/4dd369bc-aa82-4ff3-97de-514ae3000ee0' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks get 4dd369bc-aa82-4ff3-97de-514ae3000ee0
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "webhook",
  "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
  "created_at": "2026-08-22 15:28:00.000+00",
  "status": "enabled",
  "endpoint": "https://example.com/handler",
  "events": ["email.sent"],
  "signing_secret": "whsec_xxxxxxxxxx"
}
```


# List Attempts
Source: https://resend.com/docs/api-reference/webhooks/list-event-attempts

GET /webhooks/:webhook_id/events/:event_id/attempts
Retrieve the delivery attempts for a single webhook event.

## Path Parameters

The Webhook ID.

The Webhook Event ID.

## Query Parameters

**limit** `number`

Number of attempts to return. Between `1` and `100`. Defaults to `20`.

**after** `string`

The attempt ID to fetch the next page after.

The `before` parameter is not supported for this endpoint.

## Response Fields

**object** `string`

Always `list`.

**has\_more** `boolean`

Whether more attempts exist beyond this page.

**data** `array`

The delivery attempts for this event, most recent first.

**properties**

**id** `string`

The attempt ID.

**http\_status\_code** `number`

The HTTP status code your endpoint returned for this attempt.

**response** `string`

The response body your endpoint returned for this attempt.

**sent\_at** `string`

When this attempt was sent.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.events.attempts.list({
  eventId: 'msg_1srOrx2ZWZBpBUvZwXKQmoEYga2',
  webhookId: '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$attempts = $resend->webhooks->events->attempts->list(
    '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
    'msg_1srOrx2ZWZBpBUvZwXKQmoEYga2'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

attempts = resend.Webhooks.list_event_attempts(
    webhook_id='4dd369bc-aa82-4ff3-97de-514ae3000ee0',
    event_id='msg_1srOrx2ZWZBpBUvZwXKQmoEYga2',
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

attempts = Resend::Webhooks.list_event_attempts(
  '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
  'msg_1srOrx2ZWZBpBUvZwXKQmoEYga2'
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Webhooks.ListEventAttempts(
		"4dd369bc-aa82-4ff3-97de-514ae3000ee0",
		"msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _attempts = resend
    .webhooks
    .list_event_attempts(
      "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
      "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.ListWebhookEventAttemptsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListWebhookEventAttemptsResponseSuccess attempts = resend.webhooks().listEventAttempts(
            "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
            "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2"
        );
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.WebhookEventAttemptListAsync(
    new Guid( "4dd369bc-aa82-4ff3-97de-514ae3000ee0" ),
    "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2"
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/webhooks/4dd369bc-aa82-4ff3-97de-514ae3000ee0/events/msg_1srOrx2ZWZBpBUvZwXKQmoEYga2/attempts' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "atmpt_1srOrx2ZWZBpBUvZwXKQmoEYga2",
      "http_status_code": 200,
      "response": "{\"ok\":true}",
      "sent_at": "2026-08-22T15:33:12.000Z"
    },
    {
      "id": "atmpt_2ZbUCwvGmIT4mLIN6d3Yz0Ainbd",
      "http_status_code": 500,
      "response": "Internal Server Error",
      "sent_at": "2026-08-22T15:28:05.000Z"
    }
  ]
}
```


# List Events
Source: https://resend.com/docs/api-reference/webhooks/list-events

GET /webhooks/:webhook_id/events
Retrieve a list of events delivered to a webhook.

## Path Parameters

The Webhook ID.

## Query Parameters

**limit** `number`

Number of events to return. Between `1` and `100`. Defaults to `20`.

**after** `string`

The event ID to fetch the next page after.

The `before` parameter is not supported for this endpoint.

## Response Fields

**object** `string`

Always `list`.

**has\_more** `boolean`

Whether more events exist beyond this page.

**data** `array`

The events delivered to this webhook, most recent first.

**properties**

**id** `string`

The event ID. Use this to [retrieve its details](/docs/api-reference/webhooks/get-event)
or [list its attempts](/docs/api-reference/webhooks/list-event-attempts).

**type** `string`

The event type, for example `email.sent`.

**created\_at** `string`

When the event was created.

**status** `string`

Delivery status of the event to this webhook: `success`, `failed`,
`attempting`, or `pending`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.events.list({
  webhookId: '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$events = $resend->webhooks->events->list(
    '4dd369bc-aa82-4ff3-97de-514ae3000ee0'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

events = resend.Webhooks.list_events(
    webhook_id='4dd369bc-aa82-4ff3-97de-514ae3000ee0'
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

events = Resend::Webhooks.list_events('4dd369bc-aa82-4ff3-97de-514ae3000ee0')
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Webhooks.ListEvents("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _events = resend
    .webhooks
    .list_events(
      "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.ListWebhookEventsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListWebhookEventsResponseSuccess events = resend.webhooks().listEvents(
            "4dd369bc-aa82-4ff3-97de-514ae3000ee0"
        );
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.WebhookEventListAsync(
    new Guid( "4dd369bc-aa82-4ff3-97de-514ae3000ee0" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/webhooks/4dd369bc-aa82-4ff3-97de-514ae3000ee0/events' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "msg_1srOsB4mXhCqCVwAxYRNnpFZhb3",
      "type": "email.delivered",
      "created_at": "2026-08-22T15:28:00.000Z",
      "status": "failed"
    },
    {
      "id": "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
      "type": "email.sent",
      "created_at": "2026-08-22T15:27:42.000Z",
      "status": "success"
    }
  ]
}
```


# List Webhooks
Source: https://resend.com/docs/api-reference/webhooks/list-webhooks

GET /webhooks
Retrieve a list of webhooks for the authenticated user.

## Query Parameters

**limit** `number`

Number of webhooks to retrieve.
<ul><li>Default value: `20`</li>
<li>Maximum value: `100`</li>
<li>Minimum value: `1`</li></ul>

**after** `string`

The ID *after* which we'll retrieve more webhooks (for pagination).
This ID will *not* be included in the returned list. Cannot be
used with the
`before` parameter.
**before** `string`

The ID *before* which we'll retrieve more webhooks (for
pagination). This ID will *not* be included in the returned list.
Cannot be used with the `after` parameter.

> [!NOTE]
>
> You can only use either `after` or `before`
> parameter, not both. See our
> [pagination guide](/docs/api-reference/pagination) for more
> information.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.list();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->webhooks->list();
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

webhooks = resend.Webhooks.list()
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

webhooks = Resend::Webhooks.list
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Webhooks.List()
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _webhooks = resend.webhooks.list(ListOptions::default()).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.ListWebhooksResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListWebhooksResponseSuccess response = resend.webhooks().list();
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.WebhookListAsync();
Console.WriteLine( "Nr Webhooks={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/webhooks' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks list
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "list",
  "has_more": false,
  "data": [
    {
      "id": "7ab123cd-ef45-6789-abcd-ef0123456789",
      "created_at": "2026-09-10 10:15:30.000+00",
      "status": "disabled",
      "endpoint": "https://first-webhook.example.com/handler",
      "events": ["email.sent"]
    },
    {
      "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
      "created_at": "2026-08-22 15:28:00.000+00",
      "status": "enabled",
      "endpoint": "https://second-webhook.example.com/receive",
      "events": ["email.received"]
    }
  ]
}
```


# Replay Event
Source: https://resend.com/docs/api-reference/webhooks/replay-event

POST /webhooks/:webhook_id/events/:event_id/replay
Queue an additional delivery attempt for a webhook event.

> [!NOTE]
>
> Replaying an event queues one additional delivery immediately. It's the same
> action as the [dashboard's Replay
> button](/docs/webhooks/retries-and-replays#manual-replays) and does not affect the
> [automatic retry schedule](/docs/webhooks/retries-and-replays#automatic-retries)
> already running for that event.

## Path Parameters

The Webhook ID.

The Webhook Event ID.

## Response Fields

**object** `string`

Always `webhook_event`.

**id** `string`

The event ID.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.events.replay({
  eventId: 'msg_1srOrx2ZWZBpBUvZwXKQmoEYga2',
  webhookId: '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$event = $resend->webhooks->events->replay(
    '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
    'msg_1srOrx2ZWZBpBUvZwXKQmoEYga2'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

replayed = resend.Webhooks.replay_event(
    webhook_id='4dd369bc-aa82-4ff3-97de-514ae3000ee0',
    event_id='msg_1srOrx2ZWZBpBUvZwXKQmoEYga2',
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

replayed = Resend::Webhooks.replay_event(
  '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
  'msg_1srOrx2ZWZBpBUvZwXKQmoEYga2'
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Webhooks.ReplayEvent(
		"4dd369bc-aa82-4ff3-97de-514ae3000ee0",
		"msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _replayed = resend
    .webhooks
    .replay_event(
      "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
      "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.ReplayWebhookEventResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ReplayWebhookEventResponseSuccess replayed = resend.webhooks().replayEvent(
            "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
            "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2"
        );
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.WebhookEventReplayAsync(
    new Guid( "4dd369bc-aa82-4ff3-97de-514ae3000ee0" ),
    "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2"
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/webhooks/4dd369bc-aa82-4ff3-97de-514ae3000ee0/events/msg_1srOrx2ZWZBpBUvZwXKQmoEYga2/replay' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "webhook_event",
  "id": "msg_1srOrx2ZWZBpBUvZwXKQmoEYga2"
}
```


# Rotate Signing Secret
Source: https://resend.com/docs/api-reference/webhooks/rotate-signing-secret

POST /webhooks/:webhook_id/signing-secret/rotate
Generate a new signing secret for a webhook.

> [!NOTE]
>
> For 24 hours after the rotation, payloads are signed with both the new and the
> previous secret, so either one verifies them. After that, only the new secret
> does. Use that window to update the secret your application uses to [verify
> requests](/docs/webhooks/verify-webhooks-requests) without dropping events.

## Path Parameters

The Webhook ID.

## Response Fields

**object** `string`

Always `webhook`.

**id** `string`

The Webhook ID.

**signing\_secret** `string`

The new signing secret.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.rotateSigningSecret(
  '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$webhook = $resend->webhooks->rotateSigningSecret(
    '4dd369bc-aa82-4ff3-97de-514ae3000ee0'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

webhook = resend.Webhooks.rotate_signing_secret(
    webhook_id='4dd369bc-aa82-4ff3-97de-514ae3000ee0',
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

webhook = Resend::Webhooks.rotate_signing_secret(
  '4dd369bc-aa82-4ff3-97de-514ae3000ee0'
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Webhooks.RotateSigningSecret(
		"4dd369bc-aa82-4ff3-97de-514ae3000ee0",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _webhook = resend
    .webhooks
    .rotate_signing_secret("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.RotateWebhookSigningSecretResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RotateWebhookSigningSecretResponseSuccess webhook = resend.webhooks().rotateSigningSecret(
            "4dd369bc-aa82-4ff3-97de-514ae3000ee0"
        );
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.WebhookRotateSigningSecretAsync(
    new Guid( "4dd369bc-aa82-4ff3-97de-514ae3000ee0" )
);
Console.WriteLine( "Signing secret={0}", resp.Content.SigningSecret );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/webhooks/4dd369bc-aa82-4ff3-97de-514ae3000ee0/signing-secret/rotate' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks rotate-signing-secret 4dd369bc-aa82-4ff3-97de-514ae3000ee0
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "webhook",
  "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
  "signing_secret": "whsec_xxxxxxxxxx"
}
```


# Update Webhook
Source: https://resend.com/docs/api-reference/webhooks/update-webhook

PATCH /webhooks/:webhook_id
Update an existing webhook configuration.

## Path Parameters

The Webhook ID.

## Body Parameters

**endpoint** `string`

The URL where webhook events will be sent.

**events** `string[]`

Array of event types to subscribe to.

See [event types](/docs/webhooks/event-types) for available options.

**status** `string`

The webhook status. Can be either `enabled` or `disabled`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.webhooks.update(
  '430eed87-632a-4ea6-90db-0aace67ec228',
  {
    endpoint: 'https://new-webhook.example.com/handler',
    events: ['email.sent', 'email.delivered'],
    status: 'enabled',
  },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->webhooks->update('430eed87-632a-4ea6-90db-0aace67ec228', [
  'endpoint' => 'https://new-webhook.example.com/handler',
  'events' => ['email.sent', 'email.delivered'],
  'status' => 'enabled',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

params: resend.Webhooks.UpdateParams = {
    "webhook_id": "430eed87-632a-4ea6-90db-0aace67ec228",
    "endpoint": "https://new-webhook.example.com/handler",
    "events": ["email.sent", "email.delivered"],
    "status": "enabled",
}

webhook = resend.Webhooks.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

params = {
  webhook_id: '430eed87-632a-4ea6-90db-0aace67ec228',
  endpoint: 'https://new-webhook.example.com/handler',
  events: ['email.sent', 'email.delivered'],
  status: 'enabled'
}

webhook = Resend::Webhooks.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	endpoint := "https://new-webhook.example.com/handler"
	status := "enabled"
	params := &resend.UpdateWebhookRequest{
		Endpoint: &endpoint,
		Events:   []string{"email.sent", "email.delivered"},
		Status:   &status,
	}

	client.Webhooks.Update("430eed87-632a-4ea6-90db-0aace67ec228", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  events::EmailEventType::{EmailDelivered, EmailSent},
  types::{UpdateWebhookOptions, WebhookStatus},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let events = [EmailSent, EmailDelivered];
  let opts = UpdateWebhookOptions::default()
    .with_endpoint("https://new-webhook.example.com/handler")
    .with_events(events)
    .with_status(WebhookStatus::Enabled);

  let _webhook = resend
    .webhooks
    .update("430eed87-632a-4ea6-90db-0aace67ec228", opts)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.webhooks.model.UpdateWebhookOptions;
import com.resend.services.webhooks.model.UpdateWebhookResponseSuccess;
import com.resend.services.webhooks.model.WebhookStatus;
import static com.resend.services.webhooks.model.WebhookEvent.*;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateWebhookOptions options = UpdateWebhookOptions.builder()
            .endpoint("https://new-webhook.example.com/handler")
            .events(EMAIL_SENT, EMAIL_DELIVERED)
            .status(WebhookStatus.ENABLED)
            .build();

        UpdateWebhookResponseSuccess response = resend.webhooks()
            .update("430eed87-632a-4ea6-90db-0aace67ec228", options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.WebhookUpdateAsync(
    new Guid( "430eed87-632a-4ea6-90db-0aace67ec228" ),
    new WebhookData()
    {
      EndpointUrl = "https://new-webhook.example.com/handler",
      Events = [ WebhookEventType.EmailSent ],
      Status = WebhookStatus.Disabled,
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/webhooks/430eed87-632a-4ea6-90db-0aace67ec228' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "endpoint": "https://new-webhook.example.com/handler",
  "events": ["email.sent", "email.delivered"],
  "status": "enabled"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks update 430eed87-632a-4ea6-90db-0aace67ec228 \
  --endpoint https://new-webhook.example.com/handler \
  --events email.sent email.delivered \
  --status enabled
```

```json Response theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "webhook",
  "id": "430eed87-632a-4ea6-90db-0aace67ec228"
}
```


# Resend API vs SDK
Source: https://resend.com/docs/api-vs-sdk

For most use cases, the Resend SDK offers a better developer experience.

For most use cases, **the Resend SDK offers a better developer experience** than
calling the raw HTTP API directly. Resend maintains official, open source SDKs
for Node.js, PHP, Python, Ruby, Go, Rust, Java, and .NET.

> [!NOTE]
>
> **Recommendation:** Use a [Resend SDK](/docs/sdks) for your language. Call the [raw
> API](/docs/api-reference/introduction) directly only when no SDK exists for your
> stack.

## Choosing between the SDK and API

Reach for the SDK unless you have a specific reason not to. It handles
authentication, the required `User-Agent` header, request serialization, typed
responses, and error handling for you. That leaves less boilerplate to get
wrong.

| | Resend SDK (recommended) | Raw HTTP API |
| - | - | - |
| Auth & headers | Handled automatically | Set `Authorization` and `User-Agent` manually |
| Types & autocomplete | Built in | None |
| Errors | Structured error objects | Parse status codes and JSON yourself |
| Maintained by | Resend | You |

## When to use the raw API directly

Calling the API directly is a good fit when:

* There's **no official SDK** for your language or runtime.
* You're making a one-off request and don't want to add a dependency.
* You're building your own integration or wrapper.

If you do call the API directly, remember to set the required
[`User-Agent` header](/docs/api-reference/introduction#user-agent).

## Next steps

> [card] [Official SDKs](/docs/sdks)
>
> Install the SDK for your language.

> [card] [Quickstart](/docs/introduction)
>
> Send your first email in minutes.

> [card] [API Reference](/docs/api-reference/introduction)
>
> Full HTTP API documentation.

> [card] [MCP Server](/docs/mcp-server)
>
> Give your AI agent access to Resend.


# Send emails with Appwrite and Resend
Source: https://resend.com/docs/appwrite-integration

Learn how to send emails through Resend using Appwrite Messaging.

[Appwrite](https://appwrite.io) is an open-source development platform for building and scaling applications faster, offering Auth, Databases, Storage, Functions, Messaging, Realtime, and web hosting, all in one place.

Appwrite Messaging includes a native Resend provider, so you can send emails to your app's users through Resend without writing any delivery code.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

You'll also need an [Appwrite project](https://cloud.appwrite.io) with at least one user.

## 1. Add Resend as an email provider

In the Appwrite Console, navigate to **Messaging** > **Providers** > **Add provider** > **Email**. Give your provider a name, choose **Resend**, and click **Save and continue**.

> [!NOTE]
>
> The provider will be saved to your project, but not enabled until you complete
> its configuration.

In the **Configure** step, you will need to provide details from your Resend dashboard to connect your Appwrite project:

| Field | Description |
| - | - |
| API key | Head to API Keys > Create API Key. You can also follow [Resend's instructions](/docs/dashboard/api-keys/introduction) to create an API key. |
| Sender email | The provider sends emails from this sender email. The sender email needs to be an email under a [verified domain](/docs/dashboard/domains/introduction) in Resend. |
| Sender name | The sender name that appears in the emails sent from this provider. |
| Reply-to email | The reply-to email that appears in the emails sent from this provider. |
| Reply-to name | The reply-to name that appears in the emails sent from this provider. |

After adding these details, click **Save and continue** to enable the provider.

## 2. Add recipients

Appwrite Messaging delivers messages to **targets**, the different ways a user can be reached: their email addresses, phone numbers, and devices with your app installed. Targets can subscribe to **topics**, so when a message is published to a topic, all subscribed targets receive it.

Users with verified emails who signed up with [email password](https://appwrite.io/docs/products/auth/email-password), [magic URL](https://appwrite.io/docs/products/auth/magic-url), [email OTP](https://appwrite.io/docs/products/auth/email-otp), or [OAuth2](https://appwrite.io/docs/products/auth/oauth2) login already have an email target. You can also add targets to existing users by navigating to **Authentication** > **Users** > select a user > **Targets**.

To message groups of users, navigate to **Messaging** > **Topics** > **Create topic** and subscribe their targets to the topic.

Learn more about [topics](https://appwrite.io/docs/products/messaging/topics) and [targets](https://appwrite.io/docs/products/messaging/targets) in the Appwrite documentation.

## 3. Send your first email

To send a test email from the Appwrite Console, navigate to **Messaging** > **Messages** > **Create message** > **Email**. Add your message and in the targets step, select one of your test targets. Set the schedule to **Now** and click **Send**.

Verify that you can receive the message in your inbox. If not, check for logs in the Appwrite Console or in your [Resend dashboard](https://resend.com/emails).

To send emails programmatically, use an [Appwrite Server SDK](https://appwrite.io/docs/sdks#server):

```js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Client, Messaging, ID } from 'node-appwrite';

const client = new Client()
  .setEndpoint('https://<REGION>.cloud.appwrite.io/v1') // Your API endpoint
  .setProject('<PROJECT_ID>') // Your project ID
  .setKey('<API_KEY>'); // Your secret API key

const messaging = new Messaging(client);

const message = await messaging.createEmail({
  messageId: ID.unique(),
  subject: 'Welcome aboard!',
  content: 'Thanks for signing up. We are happy to have you.',
  topics: ['<TOPIC_ID>'],
});
```

Emails can be sent immediately or scheduled for a later time.


# Send emails with Base44 and Resend
Source: https://resend.com/docs/base44-integration

Learn how to add the Resend integration to your Base44 project.

[Base44](https://base44.com/) is a platform for building apps with AI. You can add Resend in a Base44 project by asking the chat to add email sending with Resend.

> [!NOTE]
>
> This integration requires backend functions, a feature available only on
> Builder tier and above. Learn more about [Base44
> pricing](https://base44.com/pricing).

## Guide

**1. Add the Resend integration in Base44**

**If starting a new app:**

1. Click **Integration** in the top nav.
2. Search for **Resend**, select it, and choose **Use This Integration**.

![Resend Integration page](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/base44-integration.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=f98f8dda5a22d0a0aa0aadc40c9324f3)

**If adding Resend to an existing app:**

1. Enable backend functions.
2. Ask the chat: "Add the Resend email integration to my app. Prompt me to provide the API key and send a welcome email to new users."

> [!NOTE]
>
> See the [Base44
> documenation](https://docs.base44.com/Integrations/Resend-integration) for
> more information.

**2. Add your Resend API key**

However you add Resend to your project, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

Copy the API key and paste it into the **RESEND\_API\_KEY** field in Base44.

![Adding your Resend API key to Base44](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/base44-integration-1.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=e10a7a52b06dde106b7a2db585bb7b30)

**3. Add a custom domain to your Resend account**

By default, you can only send emails to your own email address.

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](/docs/add-a-domain).
2. Add the custom domain to the `from` field in the `resend` function in the Base44 backend function (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/docs/dashboard/domains/introduction).


# Send emails with Bolt.new and Resend
Source: https://resend.com/docs/bolt-new-integration

Learn how to add the Resend integration to your Bolt.new project.

[Bolt.new](https://bolt.new) is a platform for building full-stack web and mobile apps via chat. You can add Resend in a Bolt.new project by asking the chat to add email sending with Resend.

![adding the Resend integration to a Bolt.new chat](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/bolt-new-integration.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=702a20abddc5efbf7b7d0b3e25c431ed)

## Guide

**1. Add your Resend API key**

To use Resend with Bolt.new, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

> [!NOTE]
>
> To safely store your Resend API key, use a `.env` file. You may need to
> include this instruction in your prompt to bolt.new. Learn more about
> [handling API keys](/docs/knowledge-base/how-to-handle-api-keys).

**2. Add a custom domain to your Resend account**

By default, you can only send emails to your own email address.

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](/docs/add-a-domain).
2. Add the custom domain to the `from` field in the `resend` function in Bolt.new (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/docs/dashboard/domains/introduction).


# Chat SDK
Source: https://resend.com/docs/chat-sdk

Build conversational email experiences using the Vercel Chat SDK and Resend.

Use this pre-built prompt with your AI agent to build with the Resend Chat SDK adapter.

# Resend Chat SDK Adapter

**Purpose:** Instructions for building bidirectional email bots using the `@resend/chat-sdk-adapter` package with the Vercel Chat SDK.

***

## Setup

### Prerequisites

* Resend API key stored in `RESEND_API_KEY` env var
* Verified domain at [https://resend.com/domains](https://resend.com/domains)
* Webhook configured for `email.received` events, or `inbox.email.received` events when you set `inboxId` or `inboxEmailAddress` (see [https://resend.com/docs/webhooks/introduction](https://resend.com/docs/webhooks/introduction))
* Inbound email receiving enabled (see [https://resend.com/docs/dashboard/receiving/introduction](https://resend.com/docs/dashboard/receiving/introduction))

### Install

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install @resend/chat-sdk-adapter chat @chat-adapter/state-memory
# or: yarn add / pnpm add / bun add
```

### Initialize

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { createResendAdapter } from '@resend/chat-sdk-adapter';
import { MemoryStateAdapter } from '@chat-adapter/state-memory';
import { Chat } from 'chat';

const resend = createResendAdapter({
  fromAddress: 'bot@example.com',
  fromName: 'My Bot', // optional
  // apiKey: "re_...",       // or set RESEND_API_KEY env var
  // webhookSecret: "whsec_..." // or set RESEND_WEBHOOK_SECRET env var
});

const chat = new Chat({
  userName: 'email-bot',
  adapters: { resend },
  state: new MemoryStateAdapter(),
});
```

### Handle Inbound Emails

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
// New email (new thread)
chat.onNewMention(async (thread, message) => {
  await thread.subscribe();
  await thread.post(`Got your email: ${message.text}`);
});

// Follow-up email in a subscribed thread
chat.onSubscribedMessage(async (thread, message) => {
  await thread.post(`Reply: ${message.text}`);
});
```

### Forward Webhooks

Point Resend webhooks to your server's `/webhook` endpoint. The adapter handles verification and parsing.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
// Inside your HTTP server handler for POST /webhook
const result = await chat.webhooks.resend(request);
```

`request` must be a Web `Request` object. If you're using Node.js `http`, convert `IncomingMessage` to a `Request` first.

***

## Configuration

| Parameter | Type | Required | Description |
| - | - | - | - |
| `fromAddress` | `string` | Yes | Sender email address |
| `fromName` | `string` | No | Display name for the From header |
| `apiKey` | `string` | No | Resend API key. Falls back to `RESEND_API_KEY` env var |
| `webhookSecret` | `string` | No | Webhook signing secret. Falls back to `RESEND_WEBHOOK_SECRET` env var |
| `inboxId` | `string` | No | Resend inbox ID. Handles `inbox.email.received` and replies in the inbox thread |
| `inboxEmailAddress` | `string` | No | Resend inbox email address. Works as `inboxId` does. Set one, not both |

***

## Threading

Threads are resolved automatically using `Message-ID`, `In-Reply-To`, and `References` headers. Reply chains are grouped into Chat SDK threads with no extra configuration.

Set `inboxId` or `inboxEmailAddress` to use an inbox, not both. With `inboxEmailAddress`, the adapter gets the inbox ID with `resend.inboxes.get()` on the first `inbox.email.received` event and keeps it. Each inbox thread maps to one Chat SDK thread with the ID `resend:{inboxId}:{threadId}`. The adapter fetches each email with `resend.inboxes.threads.emails.get()` and posts with `resend.inboxes.threads.emails.reply()`. Events for other inboxes and `email.received` events are ignored. A sender can set `Reply-To` to any address, so check `message.raw.replyTo` before replying with anything sensitive.

***

## Card Emails

Send rich HTML emails using Card elements:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
await thread.post({
  card: {
    type: 'card',
    title: 'Order Confirmed',
    children: [
      { type: 'text', content: 'Your order #1234 has been shipped.' },
      { type: 'divider' },
      {
        type: 'actions',
        children: [
          {
            type: 'link-button',
            label: 'Track Order',
            url: 'https://example.com/track/1234',
          },
        ],
      },
    ],
  },
  fallbackText: 'Order #1234 confirmed',
});
```

Cards render to HTML via `react-email`. Always include `fallbackText` for plain-text clients.

***

## Proactive Outreach

Start a new email thread without waiting for inbound:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const threadId = await resend.openDM('user@example.com');
await resend.postMessage(threadId, 'Hello from the bot!');
```

***

## Attachments

Inbound email attachments are available on `message.raw.attachments`:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { ResendRawMessage } from '@resend/chat-sdk-adapter';

chat.onNewMention(async (thread, message) => {
  const raw = message.raw as ResendRawMessage;
  const attachments = raw.attachments ?? [];
  for (const file of attachments) {
    console.log(file.filename, file.contentType);
  }
});
```

For an inbox email, each attachment has `id`, `filename`, `size` and `contentType`. The `contentType` is always `application/octet-stream`.

***

## Unsupported Operations

Email is immutable. These operations throw `NotImplementedError`:

* `editMessage` / `deleteMessage`
* `addReaction` / `removeReaction`
* `startTyping`

***

## AI Model Instructions

1. **Always** use `createResendAdapter` from `@resend/chat-sdk-adapter`
2. **Always** store API keys in env vars, never hardcode
3. **Always** call `thread.subscribe()` in `onNewMention` if you want to receive follow-ups
4. **Always** include `fallbackText` when sending card emails
5. **Never** attempt `editMessage`, `deleteMessage`, `addReaction`, `removeReaction`, or `startTyping` — email does not support these
6. The webhook handler expects a Web `Request` object — convert Node.js `IncomingMessage` if needed
7. The adapter name in Chat config must be `"resend"` for thread routing to work

For the full Resend docs: [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

The `@resend/chat-sdk-adapter` package is a [Vercel Chat SDK](https://github.com/nichochar/chat) adapter that turns email into a two-way communication channel via Resend. Receive inbound emails through webhooks, reply through the Resend API, and let the adapter handle threading automatically.

The adapter is open source and [available on GitHub](https://github.com/resend/resend-chat-sdk).

## Prerequisites

To get started, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)
* [Set up webhooks](/docs/webhooks/introduction) for `email.received` events, or for `inbox.email.received` events when you [use an inbox](#use-an-inbox)
* [Enable receiving](/docs/dashboard/receiving/introduction) on your domain

## Guide

**1. Install**

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install @resend/chat-sdk-adapter chat @chat-adapter/state-memory
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add @resend/chat-sdk-adapter chat @chat-adapter/state-memory
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add @resend/chat-sdk-adapter chat @chat-adapter/state-memory
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add @resend/chat-sdk-adapter chat @chat-adapter/state-memory
```

**2. Configure the adapter**

Create a Resend adapter and pass it with [adapter configuration options](#configuration-options) to the Chat SDK.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { createResendAdapter } from '@resend/chat-sdk-adapter';
import { MemoryStateAdapter } from '@chat-adapter/state-memory';
import { Chat } from 'chat';

const resend = createResendAdapter({
  fromAddress: 'bot@example.com',
  fromName: 'My Bot',
});

const chat = new Chat({
  userName: 'email-bot',
  adapters: { resend },
  state: new MemoryStateAdapter(),
});
```

> [!NOTE]
>
> Set `RESEND_API_KEY` and `RESEND_WEBHOOK_SECRET` as environment variables. You can also pass `apiKey` and `webhookSecret` directly in the config — explicit values take precedence over env vars.

**3. Handle inbound emails**

Register handlers for incoming emails. `onNewMention` fires when a new thread starts, and `onSubscribedMessage` fires for follow-up emails in threads you've subscribed to.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
chat.onNewMention(async (thread, message) => {
  console.log(`New email from ${message.author.userId}: ${message.text}`);
  await thread.subscribe();
  await thread.post(`Got your email: ${message.text}`);
});

chat.onSubscribedMessage(async (thread, message) => {
  await thread.post(`Reply: ${message.text}`);
});
```

**4. Forward webhooks**

Point your Resend webhooks to your server's `/webhook` endpoint. The adapter verifies the signature and parses the payload.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
if (req.method === 'POST' && req.url === '/webhook') {
  const result = await chat.webhooks.resend(request);
  res.writeHead(result.status);
  res.end();
}
```

The handler expects a Web `Request` object. If you're using Node.js `http`, convert `IncomingMessage` to a `Request` first. See the [basic example](https://github.com/resend/resend-chat-sdk/tree/main/examples/basic) for a full working server.

For webhook setup details, see [Managing Webhooks](/docs/webhooks/introduction) and [Verify Webhook Requests](/docs/webhooks/verify-webhooks-requests).

## How threading works

The adapter resolves threads using standard `Message-ID`, `In-Reply-To`, and `References` email headers. Reply chains are automatically grouped into Chat SDK threads, with no extra configuration needed.

> [!WARNING]
>
> Email is immutable. The following operations throw `NotImplementedError`: `editMessage`, `deleteMessage`, `addReaction`, `removeReaction`, and `startTyping`.

## Configuration options

| Parameter | Type | Required | Description |
| - | - | - | - |
| `fromAddress` | `string` | Yes | Sender email address |
| `fromName` | `string` | No | Display name for the From header |
| `apiKey` | `string` | No | Resend API key. Falls back to `RESEND_API_KEY` env var |
| `webhookSecret` | `string` | No | Webhook signing secret. Falls back to `RESEND_WEBHOOK_SECRET` env var |
| `inboxId` | `string` | No | Resend inbox ID. Handles `inbox.email.received` and replies in the inbox thread |
| `inboxEmailAddress` | `string` | No | Resend inbox email address. Works as `inboxId` does. Set one, not both |

## Use an inbox

Set `inboxId` or `inboxEmailAddress` to build the bot on a Resend [Inbox](/docs/api-reference/inboxes/create-inbox). The inbox groups email into threads, and the bot replies inside the thread. Resend sets the recipients and the threading headers.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = createResendAdapter({
  fromAddress: 'agent@example.com', // the inbox address
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
});
```

You can also select the inbox by its email address:

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = createResendAdapter({
  fromAddress: 'agent@example.com',
  inboxEmailAddress: 'agent@example.com',
});
```

Set `inboxId` or `inboxEmailAddress`, not both. Setting both is a type error, and the adapter throws `Set inboxId or inboxEmailAddress, not both.` The `inbox.email.received` payload identifies the inbox by its ID. With `inboxEmailAddress`, the adapter gets the inbox ID with `resend.inboxes.get()` on the first `inbox.email.received` event and keeps it.

Subscribe your webhook to `inbox.email.received`. With an inbox set, the adapter:

* Handles `inbox.email.received` events for that inbox only, and ignores other inboxes and `email.received` events.
* Maps each inbox thread to one Chat SDK thread.
* Gives each attachment `id`, `filename`, `size` and `contentType` on `message.raw.attachments`. The `contentType` is always `application/octet-stream`.
* Replies to the last received email of the thread. The reply goes to the email's `Reply-To` addresses, or to its sender when it has none. It is sent from the inbox address, so `fromName` does not apply to it.

A sender can set `Reply-To` to any address. Check `message.raw.replyTo` before the bot replies with anything sensitive. `openDM()` still sends with `resend.emails.send()` from `fromAddress`.

The inbox mode needs `@resend/chat-sdk-adapter` 0.5.0 or later and `resend` 6.34.1 or later.

## Features

> [card] [Card Emails](/docs/chat-sdk-card-emails)
>
> Send rich HTML emails with structured card elements.

> [card] [Attachments](/docs/chat-sdk-attachments)
>
> Handle inbound email attachments.

> [card] [Proactive Outreach](/docs/chat-sdk-proactive-outreach)
>
> Start new email threads without waiting for inbound.

## Examples

> [card] [Basic](https://github.com/resend/resend-chat-sdk/tree/main/examples/basic)
>
> Echo bot that replies to every email

> [card] [Welcome Cards](https://github.com/resend/resend-chat-sdk/tree/main/examples/welcome-cards)
>
> Styled card email on first contact

> [card] [Notifications](https://github.com/resend/resend-chat-sdk/tree/main/examples/notifications)
>
> Proactive outbound via openDM and HTTP POST

> [card] [Support Bot](https://github.com/resend/resend-chat-sdk/tree/main/examples/support-bot)
>
> Multi-turn conversations with subscribe/unsubscribe

> [card] [Attachments](https://github.com/resend/resend-chat-sdk/tree/main/examples/attachments)
>
> Detect attachments and reply with a summary


# Chat SDK Attachments
Source: https://resend.com/docs/chat-sdk-attachments

Handle inbound email attachments with the Chat SDK adapter.

When someone sends an email with file attachments, the adapter makes them available on `message.raw.attachments`. The adapter does not download the attachment content.

* An attachment of an `email.received` email has `filename` and `contentType`.
* An attachment of an inbox email has `id`, `filename`, `size` and `contentType`. The inbox API does not return the MIME type, so `contentType` is always `application/octet-stream`.

## Attachment shape

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
interface ResendAttachment {
  content?: string;
  contentType: string;
  filename: string;
  id?: string;
  size?: number;
  url?: string;
}
```

| Field | Type | Description |
| - | - | - |
| `content` | `string` | Base64-encoded content. The adapter does not set it |
| `contentType` | `string` | MIME type (e.g., `application/pdf`). Always `application/octet-stream` for an inbox email |
| `filename` | `string` | Original filename (e.g., `invoice.pdf`) |
| `id` | `string` | Attachment ID. Set on inbox emails only |
| `size` | `number` | Size in bytes. Set on inbox emails only |
| `url` | `string` | Download URL. The adapter does not set it |

## Detecting and processing attachments

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { ResendRawMessage } from '@resend/chat-sdk-adapter';

chat.onNewMention(async (thread, message) => {
  const raw = message.raw as ResendRawMessage;
  const attachments = raw.attachments ?? [];

  if (attachments.length === 0) {
    await thread.subscribe();
    await thread.post('Got your email. No attachments found.');
    return;
  }

  const summary = attachments
    .map((a) => `${a.filename} (${a.contentType})`)
    .join(', ');

  await thread.subscribe();
  await thread.post(`Received ${attachments.length} attachment(s): ${summary}`);
});
```

For more on receiving email attachments outside the Chat SDK, see [Receiving Attachments](/docs/dashboard/receiving/attachments).

## Try it yourself

> [card] [Attachments Example](https://github.com/resend/resend-chat-sdk/tree/main/examples/attachments)
>
> Detects attachments and replies with a summary


# Chat SDK Card Emails
Source: https://resend.com/docs/chat-sdk-card-emails

Send rich HTML card emails using the Chat SDK and React Email.

The Chat SDK adapter renders Card elements into styled HTML emails using `react-email`. This lets you send structured, branded messages without writing raw HTML.

## Card structure

A card has a `type`, `title`, optional `subtitle`, and `children` array. Children can be text blocks, dividers, link buttons, or action groups.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { CardElement } from 'chat';

const card: CardElement = {
  type: 'card',
  title: 'Order Confirmed',
  subtitle: 'Order #1234',
  children: [
    { type: 'text', content: 'Your order has been shipped.' },
    { type: 'divider' },
    {
      type: 'actions',
      children: [
        {
          type: 'link-button',
          label: 'Track Order',
          url: 'https://example.com/track/1234',
        },
      ],
    },
  ],
};
```

### Child element types

| Type | Fields | Description |
| - | - | - |
| `text` | `content` | Plain text paragraph |
| `divider` | `n/a` | Horizontal rule |
| `link-button` | `label`, `url` | Clickable button that opens a URL |
| `actions` | `children` | Container for link buttons |

## Sending a card

Pass the card object and a `fallbackText` string to `thread.post()`. The fallback is used by email clients that don't render HTML.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
chat.onNewMention(async (thread, message) => {
  await thread.subscribe();
  await thread.post({
    card: {
      type: 'card',
      title: 'Welcome!',
      subtitle: 'Thanks for reaching out',
      children: [
        {
          type: 'text',
          content: "Hi! Thanks for emailing us. We'll get back to you shortly.",
        },
        { type: 'divider' },
        {
          type: 'actions',
          children: [
            {
              type: 'link-button',
              label: 'Visit our website',
              url: 'https://resend.com',
            },
          ],
        },
      ],
    },
    fallbackText: 'Welcome! Thanks for reaching out.',
  });
});
```

> [!NOTE]
>
> Always include `fallbackText`. Some email clients strip HTML entirely, and the fallback text is what recipients will see in that case.

## Try it yourself

> [card] [Welcome Cards Example](https://github.com/resend/resend-chat-sdk/tree/main/examples/welcome-cards)
>
> Full working example that sends a styled card on first contact


# Chat SDK Proactive Outreach
Source: https://resend.com/docs/chat-sdk-proactive-outreach

Start new email conversations proactively with the Chat SDK adapter.

By default, the Chat SDK adapter responds to inbound emails. With `openDM`, you can go the other way and start a new email thread with any address, without waiting for them to email you first.

## Sending a proactive email

Call `openDM` on the adapter from `createResendAdapter` to create a new thread. Then call `postMessage` to send a message to the thread.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
const threadId = await resend.openDM('user@example.com');
await resend.postMessage(threadId, 'Hello from the bot!');
```

You can also send card emails in proactive threads. The same card structure from [Card Emails](/docs/chat-sdk-card-emails) works here.

## Triggering via HTTP

A common pattern is exposing an HTTP endpoint that triggers outbound emails. This lets external systems (cron jobs, webhooks from other services, admin dashboards) send emails through your bot.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { IncomingMessage, ServerResponse } from 'node:http';

async function readBody(req: IncomingMessage): Promise<string> {
  const chunks: Buffer[] = [];
  for await (const chunk of req) {
    chunks.push(Buffer.from(chunk));
  }
  return Buffer.concat(chunks).toString();
}

async function handleNotify(req: IncomingMessage, res: ServerResponse) {
  const { to, message } = JSON.parse(await readBody(req));

  const threadId = await resend.openDM(to);
  await resend.postMessage(threadId, message);

  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ ok: true, threadId }));
}
```

Then call it:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST http://localhost:3000/notify \
  -H "Content-Type: application/json" \
  -d '{"to": "user@example.com", "message": "Your order has shipped!"}'
```

## When to use this

* Welcome emails when a user signs up
* Order confirmations and shipping updates
* Alert notifications (monitoring, billing, security)
* Scheduled digests or reminders

If the recipient replies, the response arrives through the normal `onNewMention` or `onSubscribedMessage` handlers, and the threading is handled automatically.

## Try it yourself

> [card] [Notifications Example](https://github.com/resend/resend-chat-sdk/tree/main/examples/notifications)
>
> Proactive outbound emails via openDM and an HTTP POST endpoint


# Resend CLI
Source: https://resend.com/docs/cli

The official command-line tool for Resend. Send emails, manage your account, and develop locally from the terminal.

The [Resend CLI](https://github.com/resend/resend-cli) is the official command-line interface for Resend. It covers the full API surface and is built for humans, AI agents, and CI/CD pipelines.

## Installation

> [tab] cURL
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -fsSL https://resend.com/install.sh | bash
> ```

> [tab] npm
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> npm install -g resend-cli
> ```

> [tab] Homebrew
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> brew install resend/cli/resend
> ```

> [tab] PowerShell (Windows)
>
> ```powershell theme={"theme":{"light":"github-light","dark":"vesper"}}
> irm https://resend.com/install.ps1 | iex
> ```

## Authentication

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

| Priority | Source | How to set |
| - | - | - |
| 1 (highest) | `--api-key` flag | `resend --api-key re_xxx emails send ...` |
| 2 | `RESEND_API_KEY` env var | `export RESEND_API_KEY=re_xxx` |
| 3 (lowest) | Saved credentials | `resend login` |

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

**`resend login`**

Log in and save your credentials locally.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend login
```

In a terminal, the command asks how to log in. You can approve the login in the browser, or enter an API key through a masked input. The CLI validates an API key against the Resend API before it saves the key.

In non-interactive environments (CI, pipes, AI agents), pass `--web` or `--key`.

`--web` logs in through the browser with no prompts:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend login --web
```

The command tries to open the browser and prints the login URL to stderr. It then waits up to 5 minutes for you to approve the login. The browser must run on the same machine as the CLI. Without `--profile`, the login is saved to the `default` profile.

`--key` saves an API key:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend login --key re_xxxxxxxxxxxxx
```

Credentials are saved to your system's secure credential storage (macOS Keychain, Windows Credential Manager, or Linux secret service).

| Flag | Description |
| - | - |
| `--web` | Log in through the browser with no prompts. Can't be combined with `--key`. |
| `--key <key>` | API key to store. Required in non-interactive mode, unless you pass `--web`. |

**`resend logout`**

Remove your saved API key.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend logout
```

**Switch between profiles**

If you work across multiple Resend teams or accounts, switch between profiles without logging in and out:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend auth switch
```

Use the global `--profile` flag on any command to run it with a specific profile:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains list --profile production
```

Other profile management commands:

| Command | Description |
| - | - |
| `resend auth list` | List all profiles |
| `resend auth switch [name]` | Switch the active profile |
| `resend auth rename [old] [new]` | Rename a profile |
| `resend auth remove [name]` | Remove a profile |
| `resend whoami` | Show current authentication status |

## Emails

Send, retrieve, cancel, and manage email delivery.

**`resend emails send`**

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

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Hello World" \
  --text "It works!"
```

| Flag | Required | Description |
| - | - | - |
| `--from <address>` | Yes \* | Sender email address (must be from a verified domain) |
| `--to <addresses...>` | Yes | One or more recipient email addresses (space-separated) |
| `--subject <subject>` | Yes \* | Email subject line |
| `--text <text>` | One of text/html | Plain text body |
| `--text-file <path>` | One of text/html | Path to a plain text file (use `-` for stdin) |
| `--html <html>` | One of text/html | HTML body as a string |
| `--html-file <path>` | One of text/html | Path to an HTML file (use `-` for stdin) |
| `--react-email <path>` | One of text/html | Path to a React Email template (`.tsx`) to render and send |
| `--cc <addresses...>` | No | CC recipients |
| `--bcc <addresses...>` | No | BCC recipients |
| `--reply-to <address>` | No | Reply-to email address |
| `--scheduled-at <datetime>` | No | Schedule for later (ISO 8601 or natural language) |
| `--attachment <paths...>` | No | File path(s) to attach |
| `--headers <key=value...>` | No | Custom headers as key=value pairs |
| `--tags <name=value...>` | No | Email tags as name=value pairs |
| `--idempotency-key <key>` | No | Deduplicate this send request |
| `--template <id>` | No | Template ID to use |
| `--var <key=value...>` | No | Template variables as key=value pairs |

\* Not required when using `--template`, which provides them.

**Examples:**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
# HTML from a file
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Hello World" \
  --html-file ./welcome.html

# Multiple recipients with CC, BCC, and reply-to
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Hello World" \
  --text "It works!" \
  --cc manager@example.com \
  --bcc archive@example.com \
  --reply-to noreply@example.com

# Send a React Email template
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Hello World" \
  --react-email ./emails/welcome.tsx

# Send with a template
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --template tmpl_xxxxx \
  --var "name=Alice" --var "company=Acme"
```

**`resend emails batch`**

Send up to 100 emails in a single API request from a JSON file.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails batch --file ./emails.json
```

| Flag | Required | Description |
| - | - | - |
| `--file <path>` | Yes | Path to JSON file containing array of email objects (use `-` for stdin) |
| `--react-email <path>` | No | Path to a React Email template (`.tsx`). Rendered HTML applies to every email in the batch |
| `--idempotency-key <key>` | No | Deduplicate this batch request |
| `--batch-validation <mode>` | No | `strict` (default, entire batch fails on any error) or `permissive` |

Each email in the JSON array supports the same fields as `resend emails send`, including per-email `scheduled_at` (natural language or ISO 8601) and `tags`. The `attachments` field is not supported in batch sends.

```json emails.json theme={"theme":{"light":"github-light","dark":"vesper"}}
[
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
    "scheduled_at": "in 1 min",
    "tags": [{ "name": "category", "value": "welcome" }]
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
    "scheduled_at": "in 5 min"
  }
]
```

**Other email commands**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails list                # List sent emails
resend emails get <id>            # Retrieve a sent email by ID
resend emails cancel <id>         # Cancel a scheduled email
resend emails update <id>         # Update a scheduled email's send time
```

## Receiving

Process inbound emails, download attachments, and stream incoming messages.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails receiving list              # List received (inbound) emails
resend emails receiving get <id>          # Retrieve a received email with full details
resend emails receiving listen            # Poll for new inbound emails as they arrive
resend emails receiving forward <id>      # Forward a received email
resend emails receiving attachments <id>  # List attachments for a received email
resend emails receiving attachment <id> <attachment-id>  # Download a specific attachment
```

## Domains

Manage your sending and receiving domains.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend domains create --name example.com --region us-east-1
resend domains list               # List all domains
resend domains get <id>           # Retrieve domain with DNS records
resend domains verify <id>        # Trigger DNS verification
resend domains update <id>        # Update TLS, tracking, or receiving settings
resend domains delete <id>        # Delete a domain
```

## API Keys

Create, list, and revoke API keys for programmatic access.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend api-keys create --name "Production" --permission full_access
resend api-keys list              # List all API keys
resend api-keys delete <id>       # Delete an API key
```

## Broadcasts

Create and send broadcast emails to segments.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts create \
  --from "Acme <onboarding@resend.dev>" \
  --subject "Product update" \
  --segment-id seg_xxxxx \
  --html-file ./broadcast.html \
  --send
resend broadcasts list            # List all broadcasts
resend broadcasts get <id>        # Retrieve broadcast details
resend broadcasts send <id>       # Send a draft broadcast
resend broadcasts update <id>     # Update a draft broadcast
resend broadcasts delete <id>     # Delete a broadcast
resend broadcasts open [id]       # Open a broadcast in the dashboard
```

## Contacts

Manage contacts, segment membership, and topic subscriptions.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts create --email steve.wozniak@gmail.com --first-name Steve
resend contacts list              # List all contacts
resend contacts get <id>          # Retrieve a contact by ID or email
resend contacts update <id>       # Update contact properties
resend contacts delete <id>       # Delete a contact
resend contacts segments <id>     # List segments a contact belongs to
resend contacts add-segment <id>  # Add a contact to a segment
resend contacts remove-segment <id> <segment-id>  # Remove from a segment
resend contacts topics <id>       # List topic subscriptions
resend contacts update-topics <id>  # Update topic subscriptions
resend contacts imports create --file ./contacts.csv  # Import contacts from CSV
resend contacts imports get <id>   # Retrieve import status and counts
resend contacts imports list       # List past contact imports
```

**`resend contacts imports create`**

Start an asynchronous CSV import. The command uploads the file and returns a
contact import ID immediately. Use `resend contacts imports get <id>` to check
processing status.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts imports create \
  --file ./contacts.csv \
  --column-map '{"email":"Email","firstName":"First Name","lastName":"Last Name"}' \
  --on-conflict upsert
```

| Flag | Required | Description |
| - | - | - |
| `--file <path>` | Yes | Path to the CSV file to import. Maximum file size is 200MB |
| `--column-map <json>` | No | JSON object mapping CSV headers to contact fields |
| `--on-conflict <mode>` | No | `upsert` to update existing contacts or `skip` to leave them unchanged |
| `--segment-id <id...>` | No | Segment IDs to add imported contacts to. Repeat the flag for multiple segments |
| `--topics <json>` | No | JSON array of topic subscriptions with `id` and `subscription` fields |

Without `--column-map`, CSV headers must match the lowercase contact field
names exactly: `email`, `first_name`, and `last_name`. Use `--column-map` when
your CSV uses headers like `Email` or `First Name`.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
# Import contacts and add them to a segment
resend contacts imports create \
  --file ./contacts.csv \
  --segment-id 78261eea-8f8b-4381-83c6-79fa7120f1cf

# Map custom properties and topic subscriptions
resend contacts imports create \
  --file ./contacts.csv \
  --column-map '{"email":"Email","properties":{"plan":{"column":"Plan","type":"string"}}}' \
  --topics '[{"id":"b6d24b8e-af0b-4c3c-be0c-359bbd97381e","subscription":"opt_in"}]'
```

**`resend contacts imports get`**

Retrieve a contact import by ID, including status and row counts.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts imports get 479e3145-dd38-476b-932c-529ceb705947
```

**`resend contacts imports list`**

List contact imports. The default limit is `10`.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contacts imports list --status completed
```

| Flag | Required | Description |
| - | - | - |
| `--limit <n>` | No | Maximum number of imports to return. Must be between `1` and `100` |
| `--after <cursor>` | No | Return imports after this contact import ID |
| `--before <cursor>` | No | Return imports before this contact import ID |
| `--status <status>` | No | Filter by `queued`, `in_progress`, `completed`, or `failed` |

## Contact Properties

Define custom properties to store additional data on contacts.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend contact-properties create --key "company" --type string
resend contact-properties list | get | update | delete
```

## Segments

Group contacts into targetable segments for broadcasts.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend segments create --name "VIPs"
resend segments list              # List all segments
resend segments get <id>          # Retrieve a segment by ID
resend segments contacts <id>     # List contacts in a segment
resend segments delete <id>       # Delete a segment
```

## Topics

Manage subscription topics that contacts can opt in or out of.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend topics create --name "Product updates"
resend topics list | get | update | delete
```

## Suppressions

Manage the suppression list.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend suppressions list                              # List suppressed addresses (alias: ls)
resend suppressions list --origin bounce              # Filter by origin: bounce | complaint | manual
resend suppressions add spam@example.com              # Suppress a single address
resend suppressions get spam@example.com              # Retrieve by ID or email
resend suppressions delete spam@example.com --yes     # Remove by ID or email (alias: rm)
resend suppressions batch add --file ./emails.json    # Suppress up to 100 from a JSON array of emails
resend suppressions batch remove --file ./emails.json # Remove up to 100 (add --ids to treat entries as IDs)
```

## Templates

Create and manage email templates.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend templates create --name "Welcome" --subject "Welcome to Acme" --react-email ./emails/welcome.tsx
resend templates list             # List all templates
resend templates get <id>         # Retrieve a template by ID or alias
resend templates update <id>      # Update a template
resend templates publish <id>     # Publish a draft template
resend templates duplicate <id>   # Duplicate a template
resend templates delete <id>      # Delete a template
resend templates open [id]        # Open a template in the dashboard
```

## Logs

View API request logs.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend logs list              # List API request logs
resend logs get <id>          # Retrieve a log with full request/response bodies
resend logs open [id]         # Open logs in the dashboard
```

## Webhooks

Register endpoints and listen for email event notifications.

**`resend webhooks create`**

Register a webhook endpoint.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks create \
  --endpoint https://example.com/webhook \
  --events email.sent email.delivered
```

| Flag | Required | Description |
| - | - | - |
| `--endpoint <url>` | Yes | HTTPS URL to receive events |
| `--events <types...>` | Yes | Event types to subscribe to (use `all` for all events) |

**`resend webhooks listen`**

Listen for webhook events locally during development. Starts a server, registers a temporary webhook, streams events, and cleans up on exit.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks listen \
  --url https://hostname.tailnet-name.ts.net \
  --events email.received
```

| Flag | Required | Description |
| - | - | - |
| `--url <url>` | Yes | Your public URL (e.g., Tailscale Funnel URL) |
| `--events <types...>` | No | Event types to listen for (default: `all`) |
| `--forward-to <url>` | No | Forward payloads to a local server (passes original Svix headers) |
| `--port <port>` | No | Local server port (default: 4318) |

> [!NOTE]
>
> See the [webhook events documentation](/docs/webhooks/event-types) for the full
> list of available event types. For agent-specific webhook patterns, see [CLI
> for AI Agents](/docs/cli-agents#closing-the-loop-with-webhooks).

**Other webhook commands**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks list              # List all webhook endpoints
resend webhooks get <id>          # Retrieve a webhook configuration
resend webhooks update <id>       # Update endpoint URL, events, or status
resend webhooks delete <id>       # Delete a webhook endpoint
```

> [!TIP]
>
> Run `resend <command> --help` for the full list of flags and options on any command.

## Automations

Create, manage, and monitor event-driven automation workflows.

**`resend automations create`**

Create a new automation from a JSON file describing the workflow graph.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations create --file ./automation.json
```

| Flag | Required | Description |
| - | - | - |
| `--name <name>` | Yes \* | Automation name |
| `--status <status>` | No | Initial status: `enabled` or `disabled` (default: `disabled`) |
| `--steps <json>` | Yes \* | Steps array as JSON string |
| `--connections <json>` | Yes \* | Connections array as JSON string |
| `--file <path>` | Yes \* | Path to JSON file with full automation payload (use `-` for stdin) |

\* Provide `--file`, or `--name` with `--steps` and `--connections`. When using `--file`, other flags override file values.

**Other automation commands**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations list              # List all automations
resend automations get <id>          # Retrieve an automation with steps and connections
resend automations update <id>       # Update an automation's status (enable or disable)
resend automations duplicate <id>    # Duplicate an automation
resend automations stop <id>         # Stop an enabled automation
resend automations delete <id>       # Delete an automation
resend automations open [id]         # Open an automation in the dashboard
```

**Automation runs**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations runs list <automation-id>                    # List runs for an automation
resend automations runs list <automation-id> --status running   # Filter by status
resend automations runs get --automation-id <id> --run-id <id>  # Retrieve a specific run
```

| Flag | Required | Description |
| - | - | - |
| `--status <status>` | No | Filter by status: `running`, `completed`, `failed`, `cancelled` (comma-separated) |

## Inboxes

Create and manage inboxes, and read, reply to, and organize the email threads they receive.

Every flag below uses kebab-case, for example `--inbox-id`. Commands that act on an inbox, thread, email, draft, or label also accept the IDs as positional arguments, in that order, so `resend inboxes threads get --inbox-id <id> --thread-id <id>` and `resend inboxes threads get <inbox-id> <thread-id>` are the same. Run any command with `--help` for the full list of flags.

**`resend inboxes create`**

Create an inbox at one of your verified domains.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes create \
  --email-address hello@yourdomain.com \
  --name "Hello" \
  --from-name "Team Hello"
```

| Flag | Required | Description |
| - | - | - |
| `--email-address <address>` | Yes | Email address for the inbox, e.g. [support@yourdomain.com](mailto:support@yourdomain.com) |
| `--name <name>` | No | Inbox name shown in the Dashboard. Recipients don't see it |
| `--from-name <name>` | No | Name used when sending from this inbox, e.g. "Ada from Support" (a plain name, not "Name \<email>") |
| `--forwarding` | No | Receive mail without an MX record. Resend returns a receiving address to forward mail to |

The domain must have receiving enabled, unless you pass `--forwarding`. With `--forwarding`, run `resend inboxes get <id>` to read the `receiving_address`.

**Other inbox commands**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes list                         # List all inboxes (alias: ls)
resend inboxes get <id>                     # Retrieve an inbox by ID or email address
resend inboxes update <id> --name "Support" # Update an inbox's name or from name
resend inboxes delete <id> --yes            # Delete an inbox and its threads (alias: rm)
```

### Threads

Received emails are grouped into threads. Every thread command takes `--inbox-id`.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads list --inbox-id <id>                            # List threads, newest activity first (alias: ls)
resend inboxes threads list --inbox-id <id> --unread --folders archive # Filter by read state, folders, or labels
resend inboxes threads search --inbox-id <id> --query invoice          # Search by text, people, attachments, and dates
resend inboxes threads get --inbox-id <id> --thread-id <id>            # Retrieve a thread summary
resend inboxes threads update --inbox-id <id> --thread-id <id> --read  # Mark read or unread, or move to a folder
resend inboxes threads delete --inbox-id <id> --thread-id <id> --yes   # Move a thread to trash (alias: rm)
```

Flags for `list` and `search`:

| Flag | Required | Description |
| - | - | - |
| `--inbox-id <id>` | Yes | Inbox ID |
| `--folders <folders...>` | No | Folders to include: `inbox`, `archive`, `spam`, `sent`, `trash` |
| `--labels <label-ids...>` | No | Only threads with any of these label IDs |
| `--read` / `--unread` | No | Filter by read state |
| `--limit <n>` | No | Threads per page, 1 to 100 |
| `--after <thread-id>` | No | Pass the last thread ID of the previous page to fetch the next page |

`threads search` also accepts `--query`, `--from`, `--to`, `--cc`, `--bcc`, `--has-attachment`, `--without-attachment`, `--start-date`, and `--end-date`. Search can be up to about a minute behind new emails.

Flags for `update`:

| Flag | Required | Description |
| - | - | - |
| `--read` / `--unread` | No | Mark every email in the thread read or unread |
| `--folder <folder>` | No | Move the thread to `inbox`, `archive`, `spam`, or `trash` |

`threads update` needs `--read`, `--unread`, or `--folder`. To change a thread's labels, use the [thread labels](#thread-labels) commands.

`threads delete` moves the thread to `trash` and schedules it for deletion in 30 days. To restore it, move it to another folder with `threads update --folder`.

### Thread emails

Read, reply to, and forward the individual emails in a thread.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads emails list --inbox-id <id> --thread-id <id>                   # List emails, oldest first (alias: ls)
resend inboxes threads emails get --inbox-id <id> --thread-id <id> --email-id <id>    # Retrieve a single email
resend inboxes threads emails reply --inbox-id <id> --thread-id <id> --email-id <id> \
  --text "Thanks!"                                                                    # Reply from the inbox address
resend inboxes threads emails forward --inbox-id <id> --thread-id <id> --email-id <id> \
  --to teammate@example.com                                                           # Forward to other recipients
```

| Flag | Required | Description |
| - | - | - |
| `--text` / `--html` | Yes \* | Body of the reply, or an optional note to include with a forward |
| `--to <addresses...>` | Yes \* | Forward recipients, separated by spaces |
| `--cc` / `--bcc` | No | Additional recipients, separated by spaces |
| `--subject <subject>` | No | Override the reply or forwarded subject |
| `--reply-all` | No | Reply to everyone on the original email, not only its author |
| `--attachment <specs...>` | No | Local files or URLs to attach. Local file content can total at most 25 MB. URLs are fetched when the email is sent |
| `--idempotency-key <key>` | No | Deduplicate this send request using this key |

\* `reply` requires `--text` or `--html`. `forward` requires `--to`.

### Labels

Organize threads with labels. Apply or remove them with the [thread labels](#thread-labels) commands.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes labels list --inbox-id <id>                                      # List all labels in an inbox (alias: ls)
resend inboxes labels create --inbox-id <id> --name "Billing" --color '#12A594' # Create a label (random color when omitted)
resend inboxes labels update --inbox-id <id> --label-id <id> --name "Invoices"  # Update a label's name or color
resend inboxes labels delete --inbox-id <id> --label-id <id> --yes              # Delete a label and remove it from threads (alias: rm)
```

### Thread labels

Change the labels on a thread. Every command takes `--inbox-id` and `--thread-id`, and prints every label on the thread after the change.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads labels add --inbox-id <id> --thread-id <id> --labels <label-id>      # Add labels, keeping existing ones
resend inboxes threads labels set --inbox-id <id> --thread-id <id> --labels <label-id>      # Replace every label on the thread
resend inboxes threads labels remove --inbox-id <id> --thread-id <id> --label-id <label-id> # Remove one label from the thread
```

| Flag | Required | Description |
| - | - | - |
| `--labels <label-ids...>` | Yes \* | Label IDs, separated by spaces or commas. `add` takes 1 to 10, `set` takes 0 to 100 |
| `--label-id <id>` | Yes \* | The label to remove |

\* `add` and `set` require `--labels`. `remove` requires `--label-id`. Pass `--labels ""` to `set` to remove every label from the thread. Removing a label from a thread does not delete the label.

### Drafts

Create unsent emails in an inbox, then send them later.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts list --inbox-id <id>                                  # List drafts (alias: ls)
resend inboxes drafts create --inbox-id <id> --to user@example.com \
  --subject "Hello" --text "Body"                                           # Create a standalone draft
resend inboxes drafts get --inbox-id <id> --draft-id <id>                   # Retrieve a draft
resend inboxes drafts update --inbox-id <id> --draft-id <id> --subject "Hi" # Replace recipients, subject, or body
resend inboxes drafts send --inbox-id <id> --draft-id <id>                  # Send a draft from the inbox address
resend inboxes drafts delete --inbox-id <id> --draft-id <id> --yes          # Delete a draft (alias: rm)
```

To create a reply draft, pass `--thread-id` and `--reply-to-email-id` together. When you omit `--to`, the draft is addressed to the sender of the email it replies to, or to its `Reply-To` address. If the inbox sent that email, it is addressed to that email's recipients instead. `--cc` and `--bcc` are never filled in. If you omit `--subject`, the draft is sent with the subject of the thread, prefixed with `Re:`. An email can have only one unsent reply draft, and creating a second one returns the existing draft.

`drafts send` requires the draft to have at least one recipient, a subject, and a text or HTML body.

### Agent

Configure the instructions, tone, and actions for an inbox's agent.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes agent get --inbox-id <id>                                 # Retrieve the agent settings
resend inboxes agent update --inbox-id <id> --tone concise_professional # Update instructions, tone, or actions
```

| Flag | Required | Description |
| - | - | - |
| `--instructions <text>` | No | Instructions the agent follows (max 4000 characters) |
| `--tone <tone>` | No | Tone the agent writes in: `concise_professional`, `concise_casual`, `expanded_professional`, or `expanded_casual`. See [tone](/docs/guides/inboxes/agent#using-the-api) |
| `--actions <actions...>` | No | Replaces the full set of actions: `draft_reply`, `forward_thread`, `add_labels`, `assign_thread`, `mark_as_spam`, `archive`, `move_to_trash`. See [actions](/docs/guides/inboxes/agent#actions) |

`agent update` needs at least one flag. Omitted fields keep their current value. Pass `--instructions ""` or `--tone ""` to clear a value. List several actions separated by spaces or commas, for example `--actions draft_reply add_labels`. Pass `--actions ""` to disable all actions.

## Events

Define and send events that trigger automations.

**`resend events send`**

Send an event to trigger matching automations for a contact.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend events send \
  --event user.created \
  --email steve.wozniak@gmail.com \
  --payload '{"plan":"pro"}'
```

| Flag | Required | Description |
| - | - | - |
| `--event <name>` | Yes | Event name (e.g. `user.created`) |
| `--contact-id <id>` | One of contact | Contact ID (mutually exclusive with `--email`) |
| `--email <email>` | One of contact | Contact email (mutually exclusive with `--contact-id`) |
| `--payload <json>` | No | Event payload as JSON string |

**Other event commands**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend events create --name user.created --schema '{"plan":"string"}'
resend events list                   # List all event definitions
resend events get <id>               # Retrieve an event by ID or name
resend events update <id>            # Update an event's schema
resend events delete <id>            # Delete an event definition
resend events open                   # Open events in the dashboard
```

## Utility

Diagnose your setup, manage authentication, and configure shell completions.

**`resend doctor`**

Run environment diagnostics. Verifies your CLI version, API key, credential storage, and domain status.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend doctor
```

| Check | Pass | Warn | Fail |
| - | - | - | - |
| **CLI Version** | Running latest | Update available | N/A |
| **API Key** | Key found (shows masked key + source) | N/A | No key found |
| **Credential Storage** | Secure backend (e.g., macOS Keychain) | Plaintext file fallback | N/A |
| **API Validation** | Verified domains exist | Sending-only key, no domains, or all pending | API key invalid |

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
# JSON output
resend doctor --json
```

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "ok": true,
  "checks": [
    { "name": "CLI Version", "status": "pass", "message": "v1.7.0 (latest)" },
    {
      "name": "API Key",
      "status": "pass",
      "message": "re_...xxxx (source: env)"
    },
    {
      "name": "Credential Storage",
      "status": "pass",
      "message": "macOS Keychain"
    },
    { "name": "Domains", "status": "pass", "message": "2 verified, 0 pending" }
  ]
}
```

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

**Other utility commands**

| Command | Description |
| - | - |
| `resend whoami` | Show current authentication status |
| `resend open` | Open the Resend dashboard in your browser |
| `resend update` | Check for available CLI updates |
| `resend completion [shell]` | Generate shell completion scripts (bash, zsh, fish, powershell) |
| `resend completion --install` | Auto-install completions into your shell profile |

## Global options

These flags work on every command:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend [global options] <command> [command options]
```

| Flag | Description |
| - | - |
| `--api-key <key>` | Override API key for this invocation |
| `-p, --profile <name>` | Profile to use (overrides `RESEND_PROFILE` env var) |
| `--json` | Force JSON output even in interactive terminals |
| `-q, --quiet` | Suppress spinners and status output (implies `--json`) |
| `--insecure-storage` | Save API key as plaintext instead of secure storage |
| `--version` | Print version and exit |
| `--help` | Show help text |

## Output behavior

The CLI has two output modes that switch automatically:

| Mode | When | Stdout | Stderr |
| - | - | - | - |
| **Interactive** | Terminal (TTY) | Formatted text | Spinners, prompts |
| **Machine** | Piped, CI, or `--json` | JSON | Nothing |

Pipe to another command and JSON output activates:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend doctor | jq '.checks[].name'
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Hello World" \
  --text "It works!" | jq '.id'
```

Errors always exit with code `1` and output structured JSON:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{ "error": { "message": "No API key found", "code": "auth_error" } }
```

## CI/CD

Set `RESEND_API_KEY` as an environment variable, with no `resend login` needed:

```yaml theme={"theme":{"light":"github-light","dark":"vesper"}}
# GitHub Actions
env:
  RESEND_API_KEY: ${{ secrets.RESEND_API_KEY }}
steps:
  - run: |
      resend emails send \
        --from "Acme <onboarding@resend.dev>" \
        --to delivered@resend.dev \
        --subject "Deploy complete" \
        --text "Version ${{ github.sha }} deployed."
```

## Configuration

| Item | Path | Notes |
| - | - | - |
| Config directory | `~/.config/resend/` | Respects `$XDG_CONFIG_HOME` on Linux, `%APPDATA%` on Windows |
| Credentials | System secure storage | macOS Keychain, Windows Credential Manager, or Linux secret service |
| Install directory | `~/.resend/bin/` | Respects `$RESEND_INSTALL` |

> [card] [Using the CLI with AI Agents](/docs/cli-agents)
>
> Learn about Agent Skills, non-interactive mode, and local webhook development
> for AI agents.


# Resend CLI for AI Agents
Source: https://resend.com/docs/cli-agents

How to use the Resend CLI in AI agent workflows.

The [Resend CLI](/docs/cli) works out of the box for AI agents and CI/CD pipelines. This page covers agent-specific behavior. See the [CLI reference](/docs/cli) for installation, commands, and full documentation.

## Agent Skills

The Resend CLI includes built-in Agent Skills that help AI agents understand how to use the CLI effectively.

Install the skill using the following command:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-cli
```

## Non-interactive mode

When the CLI detects a non-TTY environment (piped output, CI runner, or the `--json` flag), it automatically switches to machine-readable mode:

* **Output:** JSON to stdout, no progress indicators
* **Exit codes:** `0` for success, `1` for errors
* **Errors:** Always include `message` and `code` fields

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{ "error": { "message": "No API key found", "code": "auth_error" } }
```

All required flags must be provided. Interactive prompts are disabled. Missing flags cause an error listing what's needed.

## Authentication

Set `RESEND_API_KEY` in the agent's environment. If no key is available, the agent can log in through the browser with `--web`:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend login --web
```

The command prints the login URL to stderr, and the agent shows that URL to the user. The command waits up to 5 minutes for the user to approve the login, so agents run it in the background. The browser must run on the same machine as the CLI. To save the login to a profile other than `default`, pass `--profile <name>`.

Never pass a literal API key to `--key`. It stays in the shell history and in the agent's logs.

## Piping from stdin

Agents generate content on the fly. Pass `-` to read from stdin instead of writing temp files:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
echo "Your order has shipped." | resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Order update" \
  --text-file -
```

This works with `--html-file -` on send and `--file -` on [batch commands](/docs/cli#emails).

## Batch sending

Send up to 100 emails in a single request by piping a JSON array into `emails batch`:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
cat emails.json | resend emails batch --file -
```

## Safe retries

Add `--idempotency-key` to prevent duplicates when your agent retries a failed request:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Welcome" \
  --text "Hello!" \
  --idempotency-key "welcome-user-123"
```

This flag is available on both `emails send` and `emails batch`.

## Scheduling

The `--scheduled-at` flag accepts ISO 8601 timestamps and natural language:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Your trial ends soon" \
  --text "Your free trial expires in 3 days." \
  --scheduled-at "tomorrow at 9am ET"
```

Cancel or reschedule with `resend emails cancel <id>` and `resend emails update <id> --scheduled-at <datetime>`.

## Reading inbound emails

Agents can process incoming email as an input source. Stream inbound emails as NDJSON with `emails receiving listen`:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails receiving listen --json
```

Or fetch a specific email with full content and attachments:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails receiving get <email-id>
```

This requires a [verified domain](/docs/dashboard/domains/introduction) with receiving enabled.

## Closing the loop with webhooks

When an agent sends an email, it often needs to know what happened next: was it delivered, did it bounce, did the recipient reply? The `webhooks listen` command gives your agent a real-time feedback loop by streaming [webhook events](/docs/webhooks/event-types) directly to the terminal.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks listen \
  --url https://hostname.tailnet-name.ts.net \
  --events email.delivered email.bounced email.received
```

The CLI registers a temporary webhook, streams matching events as JSON to stdout, and deletes the webhook when you exit (`Ctrl+C`). Use `--forward-to` to pipe payloads to a local server for processing:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend webhooks listen \
  --url https://hostname.tailnet-name.ts.net \
  --forward-to http://localhost:4321/api/webhook
```

The `--url` flag takes any public URL that points to the local server port (`4318` by default). Use any tunnel, such as [Tailscale Funnel](https://tailscale.com/kb/1223/funnel), [ngrok](https://ngrok.com/), or [localtunnel](https://theboringtech.io/).

> [!TIP]
>
> For a permanent setup, deploy a webhook handler and register it via `resend
>     webhooks create` pointing to your production URL.


# Send emails with Resend CLI
Source: https://resend.com/docs/cli-quickstart

Learn how to send your first email using the Resend CLI.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

> [tab] cURL
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -fsSL https://resend.com/install.sh | bash
> ```

> [tab] npm
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> npm install -g resend-cli
> ```

> [tab] Homebrew
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> brew install resend/cli/resend
> ```

> [tab] PowerShell (Windows)
>
> ```powershell theme={"theme":{"light":"github-light","dark":"vesper"}}
> irm https://resend.com/install.ps1 | iex
> ```

**2. Authenticate**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend login
```

**3. Send email**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Hello World" \
  --text "Sent from my terminal."
```

## Next steps

> [card] [CLI Reference](/docs/cli)
>
> Explore the full command reference, authentication options, and CI/CD
> examples.


# Create an API key
Source: https://resend.com/docs/create-an-api-key

Get started sending emails by creating an API key

## Resend API keys

API Keys are secret tokens used to authenticate your requests. They are unique to your account and must be kept confidential.

You must create at least one API key to use the Resend platform through code (e.g., SDKs, API, command-line interface (CLI), or AI tools).

## Create an API Key

You can create API keys in four ways:

* in the [**API keys** Dashboard page](/docs/dashboard/api-keys/introduction)
* using the [Resend API](/docs/api-reference/api-keys/create-api-key)
* with a [Resend CLI command](/docs/cli#api-keys)
* with the [Resend MCP server](/docs/mcp-server)

To create a new API Key from the Resend Dashboard:

**1. In your Resend Dashboard, navigate to the API keys page.**

**2. Click the Create API Key button.**

**3. Provide a name for your API Key.**

Choose a name (maximum 50 characters) to identify your key.

**4. Select a permission for your API key.**

Choose **"Sending access"** to grant access to only sending emails unless your key needs full access to Resend’s API to create, delete, get, and update any resource.

This [API key permission](/docs/api-reference/api-keys/create-api-key#param-permission) can be updated at any time [in the Dashboard](/docs/dashboard/api-keys/introduction#edit-api-key-details).

**5. (Optional) Restrict sending to a specific domain**

If you selected **"Sending access"**, you can further choose the domain you want to restrict access to.

![Add API Key modal in the Resend Dashboard](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-api-keys-add.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=1ecfaf7a2d2a780b826f941078e427b5)

> [!NOTE]
>
> For security reasons, you can only view the API Key once. Learn more about
> [API key best practices](/docs/knowledge-base/how-to-handle-api-keys).

## Use the API key in your code

Authenticate your requests by adding your Resend API key to your project as an environment variable.

You can check the [quickstart guides](/docs/introduction) or [AI builder guides](/docs/ai-onboarding#ai-builder-guides) for specific examples of passing your API key to your project.

**1. Create and store an environment variable**

Store your API key as an environment variable in your project. This is commonly done inside a special file or configuration panel and will depend on your language, framework, or development platform.

For example, Node.js projects commonly store both public and secret variables in a `.env` file at the root of your project:

```sh .env theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY=re_xxxxxxxxx
```

> [!TIP]
>
> If you are storing your secrets in a project file, you may need to add this file to your `.gitignore` file to prevent it from being committed to version control.
>
> Many frameworks add `.env` to the `.gitignore` file by default, so this may already exist.
>
> ```ts .gitignore theme={"theme":{"light":"github-light","dark":"vesper"}}
> .env
> ```

**2. Pass the environment variable to your code**

Your project environment variables are not automatically available to Resend. You must explicitly pass your API key value to your Resend code.

For example, whenever you create a new Resend instance in a Node.js project, you must pass the environment variable on `process.env`:

```ts app.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend(process.env.RESEND_API_KEY);
```

> [!NOTE]
>
> On Node.js `v20` and later, you can pass your `.env` file's variables to your script using the `--env-file=.env` flag. Alternatively, you can use the `dotenv` package to load the variables.

## Learn more

> [card] [Manage API keys](/docs/dashboard/api-keys/introduction)
>
> View, create, edit, delete, and manage your API keys.

> [card] [API key best practices](/docs/knowledge-base/how-to-handle-api-keys)
>
> Learn about best practices for managing your API keys.

## Next steps

> [card] [Add a domain](/docs/add-a-domain)
>
> Add and verify a domain you own to start sending emails.

> [card] [Quickstart tutorials](/docs/introduction)
>
> Send your first transactional email with a quick tutorial for your language
> or framework.


# Manage API keys
Source: https://resend.com/docs/dashboard/api-keys/introduction

Learn how to view, edit, and delete your API keys in Resend.

## API keys

API keys are secret tokens used to authenticate your requests. They are unique to your account and must be kept confidential.

You can use multiple keys to isolate different application actions to different API keys. This allows you to [view logs per key](#view-api-key-logs), detect possible abuse, and control any damage that may be done accidentally or maliciously.

## API key management

You can view and manage your API keys from the [**API keys** Dashboard page](https://resend.com/api-keys). You can also manage your API keys programmatically using the [API](/docs/api-reference/api-keys/create-api-key) or the [Resend CLI](/docs/cli#api-keys):

* [Create](/docs/api-reference/api-keys/create-api-key) a new API key with a name, permission, and optional domain restriction
* [List](/docs/api-reference/api-keys/list-api-keys) all API keys in your account
* [Update](/docs/api-reference/api-keys/update-api-key) an API key's name (other properties can only be edited in the Dashboard)
* [Delete](/docs/api-reference/api-keys/delete-api-key) an API key

## View all API keys

The [API Dashboard](https://resend.com/api-keys) shows you all the API keys you have created along with their details, including the **last time you used** an API key.

Different color indicators let you quickly scan and detect which API keys are being used and which are not.

![View All API keys](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-api-keys-view-all.jpg?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=f195ef7f60a110407e2739f30c10ca2a)

## Edit API key details

After [creating an API key](/docs/create-an-api-key), you can edit the following details:

* [Name](/docs/api-reference/api-keys/create-api-key#param-name)
* [Permission](/docs/api-reference/api-keys/create-api-key#param-permission)
* [Domain](/docs/api-reference/api-keys/create-api-key#domain-id)

> [!NOTE]
>
> You cannot view or edit an API key value after it has been created.

To edit an API key in the Resend Dashboard, click the **More options**  button and then **Edit API key**.

You can also rename an API key programmatically using the [Update API key endpoint](/docs/api-reference/api-keys/update-api-key). The API only updates the key's name, while permission and domain can only be edited in the Dashboard.

![View Inactive API key](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-api-keys-edit.jpeg?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=7abe8e055cf311a7f66a40477db7946a)

## Delete inactive API keys

If an API key **hasn't been used in the last 30 days**, consider deleting it to keep your account secure.

![View Inactive API key](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-api-keys-view-inactive.jpg?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=fa99650454696902100e03b669d3a9c1)

You can delete an API key by clicking the **More options**  button and then **Remove API key**.

![Delete API key](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-api-keys-remove.jpeg?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=9fc76ff5dc4cd38f465539cd3a435706)

> [!TIP]
>
> See more [API key security practices](/docs/knowledge-base/how-to-handle-api-keys).

## View API key logs

When visualizing an active API key, you can see the **total number of requests** made to the key. For more detailed logging information, select the underlined number of requests to view all logs for that API key.

![View Active API key](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-api-keys-view-active.jpg?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=e0c0584545565e1e78e460b240d2c221)

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

> [!NOTE]
>
> Currently, exports are limited to admin users of your team.

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

> [!NOTE]
>
> All exports your team creates are listed in the
> [Exports](https://resend.com/exports) page under **Settings** > **Team** >
> **Exports**. Select any export to view its details page. All members of your
> team can view your exports, but only admins can download the data.


# Add to Segment
Source: https://resend.com/docs/dashboard/automations/add-to-segment

Include contacts to a segment as part of your Automation.

This step adds the current contact to a specified [Segment](/docs/dashboard/segments/introduction) when reached in the Automation flow.

Common use cases:

* **Cohorts**: Add contacts to a cohort segment after a specific event.
* **Lifecycle**: Segment contacts as they progress through onboarding.
* **Engagement**: Group contacts who completed a specific action.

## How it works

> [tab] Using the dashboard
>
> Define a **Add to segment** step and select the segment from the dropdown.
>
> ![Automation Add to Segment](https://mintcdn.com/resend/C4ZmHxGOgdpKqZkf/images/automations-add-to-segment.png?fit=max\&auto=format\&n=C4ZmHxGOgdpKqZkf\&q=85\&s=4f48bf99d7854095810c5510a8605c99)

> [tab] Using the API
>
> The `add_to_segment` step accepts a single `segment_id` field.
>
> ```ts Node.js {13-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.create({
>   name: 'Tag VIP Users',
>   steps: [
>     {
>       key: 'start',
>       type: 'trigger',
>       config: { eventName: 'purchase.completed' },
>     },
>     {
>       key: 'vip_users',
>       type: 'add_to_segment',
>       config: {
>         segmentId: '83a1e324-26dc-47eb-9b28-ba8b6d1fe808',
>       },
>     },
>   ],
>   connections: [{ from: 'start', to: 'vip_users', type: 'default' }],
> });
> ```
>
> ```php PHP {11-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->create([
>   'name' => 'Tag VIP Users',
>   'steps' => [
>     [
>       'key' => 'start',
>       'type' => 'trigger',
>       'config' => ['event_name' => 'purchase.completed'],
>     ],
>     [
>       'key' => 'vip_users',
>       'type' => 'add_to_segment',
>       'config' => [
>         'segment_id' => '83a1e324-26dc-47eb-9b28-ba8b6d1fe808',
>       ],
>     ],
>   ],
>   'connections' => [['from' => 'start', 'to' => 'vip_users', 'type' => 'default']],
> ]);
> ```
>
> ```python Python {13-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Automations.CreateParams = {
>   "name": "Tag VIP Users",
>   "steps": [
>     {
>       "key": "start",
>       "type": "trigger",
>       "config": {"event_name": "purchase.completed"},
>     },
>     {
>       "key": "vip_users",
>       "type": "add_to_segment",
>       "config": {
>         "segment_id": "83a1e324-26dc-47eb-9b28-ba8b6d1fe808",
>       },
>     },
>   ],
>   "connections": [{"from": "start", "to": "vip_users", "type": "default"}],
> }
>
> resend.Automations.create(params)
> ```
>
> ```ruby Ruby {13-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   name: "Tag VIP Users",
>   steps: [
>     {
>       key: "start",
>       type: "trigger",
>       config: { event_name: "purchase.completed" },
>     },
>     {
>       key: "vip_users",
>       type: "add_to_segment",
>       config: {
>         segment_id: "83a1e324-26dc-47eb-9b28-ba8b6d1fe808",
>       },
>     },
>   ],
>   connections: [{ from: "start", to: "vip_users", type: "default" }],
> }
>
> Resend::Automations.create(params)
> ```
>
> ```go Go {18-24} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	params := &resend.CreateAutomationRequest{
> 		Name: "Tag VIP Users",
> 		Steps: []resend.AutomationStep{
> 			{
> 				Key:  "start",
> 				Type: resend.AutomationStepTypeTrigger,
> 				Config: map[string]any{
> 					"event_name": "purchase.completed",
> 				},
> 			},
> 			{
> 				Key:  "vip_users",
> 				Type: resend.AutomationStepTypeAddToSegment,
> 				Config: map[string]any{
> 					"segment_id": "83a1e324-26dc-47eb-9b28-ba8b6d1fe808",
> 				},
> 			},
> 		},
> 		Connections: []resend.AutomationConnection{
> 			{From: "start", To: "vip_users", Type: resend.AutomationConnectionTypeDefault},
> 		},
> 	}
>
> 	client.Automations.Create(params)
> }
> ```
>
> ```rust Rust {22-27} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   types::{
>     AddToSegmentStepConfig, AutomationStatus, Connection, ConnectionType, CreateAutomationOptions,
>     Step, TriggerStepConfig,
>   },
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let opts = CreateAutomationOptions {
>     name: "Tag VIP Users".to_owned(),
>     steps: vec![
>       Step::Trigger {
>         key: "start".to_owned(),
>         config: TriggerStepConfig {
>           event_name: "purchase.completed".to_owned(),
>         },
>       },
>       Step::AddToSegment {
>         key: "vip_users".to_owned(),
>         config: AddToSegmentStepConfig {
>           segment_id: "83a1e324-26dc-47eb-9b28-ba8b6d1fe808".to_owned(),
>         },
>       },
>     ],
>     connections: vec![Connection::new("start", "vip_users").with_type(ConnectionType::Default)],
>     status: AutomationStatus::Disabled,
>   };
>   let _automation = resend.automations.create(opts).await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {20-24} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.AutomationConnection;
> import com.resend.services.automations.model.AutomationStep;
> import com.resend.services.automations.model.ConnectionType;
> import com.resend.services.automations.model.CreateAutomationOptions;
> import com.resend.services.automations.model.CreateAutomationResponseSuccess;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         CreateAutomationOptions options = CreateAutomationOptions.builder()
>                 .name("Tag VIP Users")
>                 .steps(
>                     AutomationStep.trigger("start")
>                         .eventName("purchase.completed")
>                         .build(),
>                     AutomationStep.addToSegment("vip_users")
>                         .segmentId("83a1e324-26dc-47eb-9b28-ba8b6d1fe808")
>                         .build()
>                 )
>                 .connections(
>                     AutomationConnection.builder()
>                         .from("start")
>                         .to("vip_users")
>                         .type(ConnectionType.DEFAULT)
>                         .build()
>                 )
>                 .build();
>
>         CreateAutomationResponseSuccess data = resend.automations().create(options);
>     }
> }
> ```
>
> ```csharp .NET {7,15} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var startConfig = JsonSerializer.SerializeToElement( new { event_name = "purchase.completed" } );
> var segmentConfig = JsonSerializer.SerializeToElement( new { segment_id = "83a1e324-26dc-47eb-9b28-ba8b6d1fe808" } );
>
> var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
> {
>     Name = "Tag VIP Users",
>     Steps = new List<AutomationStepData>
>     {
>         new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
>         new AutomationStepData { Ref = "vip_users", Type = "add_to_segment", Config = segmentConfig },
>     },
>     Connections = new List<AutomationEdge>
>     {
>         new AutomationEdge { From = "start", To = "vip_users", EdgeType = "default" },
>     },
> } );
> ```
>
> ```bash cURL {10-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/automations' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "name": "Tag VIP Users",
>   "steps": [{
>     "key": "start",
>     "type": "trigger",
>     "config": { "event_name": "purchase.completed" }
>   }, {
>     "key": "vip_users",
>     "type": "add_to_segment",
>     "config": { "segment_id": "83a1e324-26dc-47eb-9b28-ba8b6d1fe808" }
>   }],
>   "connections": [
>     { "from": "start", "to": "vip_users", "type": "default" }
>   ]
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations create --name "Tag VIP Users" --file ./automation.json
> ```

## Configuration

**config.segment\_id** `string` *required*

The ID of the segment to add the contact to.

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "add_to_vip",
  "type": "add_to_segment",
  "config": {
    "segment_id": "83a1e324-26dc-47eb-9b28-ba8b6d1fe808"
  }
}
```


# Condition
Source: https://resend.com/docs/dashboard/automations/condition

Route contacts through different paths based on conditions.

A branch step evaluates a condition against event or contact data and routes the Automation down one of two paths: **condition met** or **condition not met**.

Common use cases:

* **Plan-based emails**: Send different content to free vs. paid users.
* **Engagement splits**: Take different actions based on user activity.
* **Personalization**: Tailor follow-ups based on event payload values.

## How it works

> [tab] Using the dashboard
>
> Add a **Condition** step and configure the condition using the editor.
>
> ![Automation Branch](https://mintcdn.com/resend/x30lv_t_NKKbe7WS/images/automations-branch.png?fit=max\&auto=format\&n=x30lv_t_NKKbe7WS\&q=85\&s=0079e0e52cf7c13d7645a7467c531696)

> [tab] Using the API
>
> The condition step accepts a `type` and the corresponding rule fields.
>
> ```ts Node.js {13-22} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.create({
>   name: 'Plan-based Welcome',
>   steps: [
>     {
>       key: 'start',
>       type: 'trigger',
>       config: { eventName: 'user.created' },
>     },
>     {
>       key: 'check_plan',
>       type: 'condition',
>       config: {
>         type: 'rule',
>         field: 'event.plan',
>         operator: 'eq',
>         value: 'pro',
>       },
>     },
>     {
>       key: 'send_pro_email',
>       type: 'send_email',
>       config: { template: { id: 'pro-welcome-template-id' } },
>     },
>     {
>       key: 'send_free_email',
>       type: 'send_email',
>       config: { template: { id: 'free-welcome-template-id' } },
>     },
>   ],
>   connections: [
>     { from: 'start', to: 'check_plan', type: 'default' },
>     { from: 'check_plan', to: 'send_pro_email', type: 'condition_met' },
>     {
>       from: 'check_plan',
>       to: 'send_free_email',
>       type: 'condition_not_met',
>     },
>   ],
> });
> ```
>
> ```php PHP {11-20} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->create([
>   'name' => 'Plan-based Welcome',
>   'steps' => [
>     [
>       'key' => 'start',
>       'type' => 'trigger',
>       'config' => ['event_name' => 'user.created'],
>     ],
>     [
>       'key' => 'check_plan',
>       'type' => 'condition',
>       'config' => [
>         'type' => 'rule',
>         'field' => 'event.plan',
>         'operator' => 'eq',
>         'value' => 'pro',
>       ],
>     ],
>     [
>       'key' => 'send_pro_email',
>       'type' => 'send_email',
>       'config' => ['template' => ['id' => 'pro-welcome-template-id']],
>     ],
>     [
>       'key' => 'send_free_email',
>       'type' => 'send_email',
>       'config' => ['template' => ['id' => 'free-welcome-template-id']],
>     ],
>   ],
>   'connections' => [
>     ['from' => 'start', 'to' => 'check_plan', 'type' => 'default'],
>     ['from' => 'check_plan', 'to' => 'send_pro_email', 'type' => 'condition_met'],
>     ['from' => 'check_plan', 'to' => 'send_free_email', 'type' => 'condition_not_met'],
>   ],
> ]);
> ```
>
> ```python Python {13-22} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Automations.CreateParams = {
>   "name": "Plan-based Welcome",
>   "steps": [
>     {
>       "key": "start",
>       "type": "trigger",
>       "config": {"event_name": "user.created"},
>     },
>     {
>       "key": "check_plan",
>       "type": "condition",
>       "config": {
>         "type": "rule",
>         "field": "event.plan",
>         "operator": "eq",
>         "value": "pro",
>       },
>     },
>     {
>       "key": "send_pro_email",
>       "type": "send_email",
>       "config": {"template": {"id": "pro-welcome-template-id"}},
>     },
>     {
>       "key": "send_free_email",
>       "type": "send_email",
>       "config": {"template": {"id": "free-welcome-template-id"}},
>     },
>   ],
>   "connections": [
>     {"from": "start", "to": "check_plan", "type": "default"},
>     {"from": "check_plan", "to": "send_pro_email", "type": "condition_met"},
>     {"from": "check_plan", "to": "send_free_email", "type": "condition_not_met"},
>   ],
> }
>
> resend.Automations.create(params)
> ```
>
> ```ruby Ruby {13-22} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   name: "Plan-based Welcome",
>   steps: [
>     {
>       key: "start",
>       type: "trigger",
>       config: { event_name: "user.created" },
>     },
>     {
>       key: "check_plan",
>       type: "condition",
>       config: {
>         type: "rule",
>         field: "event.plan",
>         operator: "eq",
>         value: "pro",
>       },
>     },
>     {
>       key: "send_pro_email",
>       type: "send_email",
>       config: { template: { id: "pro-welcome-template-id" } },
>     },
>     {
>       key: "send_free_email",
>       type: "send_email",
>       config: { template: { id: "free-welcome-template-id" } },
>     },
>   ],
>   connections: [
>     { from: "start", to: "check_plan", type: "default" },
>     { from: "check_plan", to: "send_pro_email", type: "condition_met" },
>     { from: "check_plan", to: "send_free_email", type: "condition_not_met" },
>   ],
> }
>
> Resend::Automations.create(params)
> ```
>
> ```go Go {18-27} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	params := &resend.CreateAutomationRequest{
> 		Name: "Plan-based Welcome",
> 		Steps: []resend.AutomationStep{
> 			{
> 				Key:  "start",
> 				Type: resend.AutomationStepTypeTrigger,
> 				Config: map[string]any{
> 					"event_name": "user.created",
> 				},
> 			},
> 			{
> 				Key:  "check_plan",
> 				Type: resend.AutomationStepTypeCondition,
> 				Config: map[string]any{
> 					"type":     "rule",
> 					"field":    "event.plan",
> 					"operator": "eq",
> 					"value":    "pro",
> 				},
> 			},
> 			{
> 				Key:  "send_pro_email",
> 				Type: resend.AutomationStepTypeSendEmail,
> 				Config: map[string]any{
> 					"template": map[string]any{"id": "pro-welcome-template-id"},
> 				},
> 			},
> 			{
> 				Key:  "send_free_email",
> 				Type: resend.AutomationStepTypeSendEmail,
> 				Config: map[string]any{
> 					"template": map[string]any{"id": "free-welcome-template-id"},
> 				},
> 			},
> 		},
> 		Connections: []resend.AutomationConnection{
> 			{From: "start", To: "check_plan", Type: resend.AutomationConnectionTypeDefault},
> 			{From: "check_plan", To: "send_pro_email", Type: resend.AutomationConnectionTypeConditionMet},
> 			{From: "check_plan", To: "send_free_email", Type: resend.AutomationConnectionTypeConditionNotMet},
> 		},
> 	}
>
> 	client.Automations.Create(params)
> }
> ```
>
> ```rust Rust {23-31} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   json,
>   types::{
>     AutomationStatus, AutomationTemplate, Connection, ConnectionType, CreateAutomationOptions,
>     SendEmailStepConfig, Step, TriggerStepConfig,
>   },
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let opts = CreateAutomationOptions {
>     name: "Plan-based Welcome".to_owned(),
>     steps: vec![
>       Step::Trigger {
>         key: "start".to_owned(),
>         config: TriggerStepConfig {
>           event_name: "user.created".to_owned(),
>         },
>       },
>       Step::Condition {
>         key: "check_plan".to_owned(),
>         config: json!({
>           "type": "rule",
>           "field": "event.plan",
>           "operator": "eq",
>           "value": "pro",
>         }),
>       },
>       Step::SendEmail {
>         key: "send_pro_email".to_owned(),
>         config: SendEmailStepConfig::new(AutomationTemplate::new("pro-welcome-template-id")),
>       },
>       Step::SendEmail {
>         key: "send_free_email".to_owned(),
>         config: SendEmailStepConfig::new(AutomationTemplate::new("free-welcome-template-id")),
>       },
>     ],
>     connections: vec![
>       Connection::new("start", "check_plan").with_type(ConnectionType::Default),
>       Connection::new("check_plan", "send_pro_email").with_type(ConnectionType::ConditionMet),
>       Connection::new("check_plan", "send_free_email").with_type(ConnectionType::ConditionNotMet),
>     ],
>     status: AutomationStatus::Disabled,
>   };
>   let _automation = resend.automations.create(opts).await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {22-29} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.AutomationConnection;
> import com.resend.services.automations.model.AutomationStep;
> import com.resend.services.automations.model.ConditionOperator;
> import com.resend.services.automations.model.ConditionRule;
> import com.resend.services.automations.model.ConnectionType;
> import com.resend.services.automations.model.CreateAutomationOptions;
> import com.resend.services.automations.model.CreateAutomationResponseSuccess;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         CreateAutomationOptions options = CreateAutomationOptions.builder()
>                 .name("Plan-based Welcome")
>                 .steps(
>                     AutomationStep.trigger("start")
>                         .eventName("user.created")
>                         .build(),
>                     AutomationStep.condition("check_plan")
>                         .rule(ConditionRule.builder()
>                                 .field("event.plan")
>                                 .operator(ConditionOperator.EQ)
>                                 .value("pro")
>                                 .build())
>                         .build(),
>                     AutomationStep.sendEmail("send_pro_email")
>                         .template("pro-welcome-template-id")
>                         .build(),
>                     AutomationStep.sendEmail("send_free_email")
>                         .template("free-welcome-template-id")
>                         .build()
>                 )
>                 .connections(
>                     AutomationConnection.builder()
>                         .from("start")
>                         .to("check_plan")
>                         .type(ConnectionType.DEFAULT)
>                         .build(),
>                     AutomationConnection.builder()
>                         .from("check_plan")
>                         .to("send_pro_email")
>                         .type(ConnectionType.CONDITION_MET)
>                         .build(),
>                     AutomationConnection.builder()
>                         .from("check_plan")
>                         .to("send_free_email")
>                         .type(ConnectionType.CONDITION_NOT_MET)
>                         .build()
>                 )
>                 .build();
>
>         CreateAutomationResponseSuccess data = resend.automations().create(options);
>     }
> }
> ```
>
> ```csharp .NET {7-13,23} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.created" } );
> var conditionConfig = JsonSerializer.SerializeToElement( new
> {
>     type = "rule",
>     field = "event.plan",
>     @operator = "eq",
>     value = "pro",
> } );
> var proEmailConfig = JsonSerializer.SerializeToElement( new { template = new { id = "pro-welcome-template-id" } } );
> var freeEmailConfig = JsonSerializer.SerializeToElement( new { template = new { id = "free-welcome-template-id" } } );
>
> var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
> {
>     Name = "Plan-based Welcome",
>     Steps = new List<AutomationStepData>
>     {
>         new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
>         new AutomationStepData { Ref = "check_plan", Type = "condition", Config = conditionConfig },
>         new AutomationStepData { Ref = "send_pro_email", Type = "send_email", Config = proEmailConfig },
>         new AutomationStepData { Ref = "send_free_email", Type = "send_email", Config = freeEmailConfig },
>     },
>     Connections = new List<AutomationEdge>
>     {
>         new AutomationEdge { From = "start", To = "check_plan", EdgeType = "default" },
>         new AutomationEdge { From = "check_plan", To = "send_pro_email", EdgeType = "condition_met" },
>         new AutomationEdge { From = "check_plan", To = "send_free_email", EdgeType = "condition_not_met" },
>     },
> } );
> ```
>
> ```bash cURL {10-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/automations' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "name": "Plan-based Welcome",
>   "steps": [{
>     "key": "start",
>     "type": "trigger",
>     "config": { "event_name": "user.created" }
>   }, {
>     "key": "check_plan",
>     "type": "condition",
>     "config": {
>       "type": "rule",
>       "field": "event.plan",
>       "operator": "eq",
>       "value": "pro"
>     }
>   }, {
>     "key": "send_pro_email",
>     "type": "send_email",
>     "config": { "template": { "id": "pro-welcome-template-id" } }
>   }, {
>     "key": "send_free_email",
>     "type": "send_email",
>     "config": { "template": { "id": "free-welcome-template-id" } }
>   }],
>   "connections": [
>     { "from": "start", "to": "check_plan", "type": "default" },
>     { "from": "check_plan", "to": "send_pro_email", "type": "condition_met" },
>     { "from": "check_plan", "to": "send_free_email", "type": "condition_not_met" }
>   ]
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations create --name "Plan-based Welcome" --file ./automation.json
> ```

## Connection types

A condition step always produces two outgoing connections.

| Connection type | Description |
| - | - |
| `condition_met` | Taken when the condition evaluates to true |
| `condition_not_met` | Taken when the condition evaluates to false |

```json {4,9} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "from": "check_plan",
  "to": "send_pro_email",
  "type": "condition_met"
},
{
  "from": "check_plan",
  "to": "send_free_email",
  "type": "condition_not_met"
}
```

## Compare against other data

A rule's `value` can reference data instead of a fixed value. This lets a condition compare two values from the Automation.

`field` and `value` can read:

* `event.*`, the event that triggered the Automation.
* `contact.*`, the contact.
* `wait_events.<event_name>.*`, an event a previous [wait for event](/docs/dashboard/automations/wait-for-event#use-the-received-event-in-later-steps) step received. If the Automation waited for that event more than once, this is the most recent one before this step.

A `value` that points at data that doesn't exist never matches.

For example, after a [wait for event](/docs/dashboard/automations/wait-for-event) step for `order.shipped`, check that the shipped order is the one that triggered the Automation:

```json {6-8} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "check_same_order",
  "type": "condition",
  "config": {
    "type": "rule",
    "field": "wait_events.order.shipped.order_id",
    "operator": "eq",
    "value": { "var": "event.order_id" }
  }
}
```

## Configuration

**config.type** `string` *required*

The type of condition node. Possible values:

* `rule`
* `and`
* `or`

For `rule` type:

**config.field** `string` *required*

The field to evaluate on a condition step. Use `event.` for the event that
triggered the Automation, `contact.` for the contact, or `wait_events.` for an
event received by a preceding wait for event step (for example,
`event.amount`, `contact.email`, or `wait_events.order.shipped.order_id`). A
wait for event `filter_rule` cannot use `wait_events.`.

**config.operator** `string` *required*

The comparison operator. Possible values:

* `eq`: equals
* `neq`: not equals
* `gt`: greater than
* `gte`: greater than or equal to
* `lt`: less than
* `lte`: less than or equal to
* `contains`: contains a given value
* `starts_with`: starts with a given value
* `ends_with`: ends with a given value
* `exists`: field exists
* `is_empty`: field is empty

**config.value** `string | number | boolean | null | object`

The value to compare against on a condition step. Either a fixed value or a
variable reference such as `{ "var": "event.order_id" }`, using the
condition namespaces: `event.` (the triggering event), `contact.`, or
`wait_events.` (a preceding wait for event). Not required for `exists` and
`is_empty` operators.

For `and` / `or` types:

**config.rules** `object[]` *required*

An array of nested condition config objects. Must contain at least one item.

Single rule example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "check_plan",
  "type": "condition",
  "config": {
    "type": "rule",
    "field": "event.plan",
    "operator": "eq",
    "value": "pro"
  }
}
```

Use `and` or `or` to combine multiple rules into a single branch:

```json {5-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "check_plan_and_amount",
  "type": "condition",
  "config": {
    "type": "and",
    "rules": [
      {
        "type": "rule",
        "field": "event.plan",
        "operator": "eq",
        "value": "pro"
      },
      {
        "type": "rule",
        "field": "event.amount",
        "operator": "gte",
        "value": 100
      }
    ]
  }
}
```


# Connections
Source: https://resend.com/docs/dashboard/automations/connections

Connections between steps in Automation workflows.

## How it works

Connections are the code definitions for the links between steps in the Automation graph and are defined and retrieved using the API.

If creating an Automation via the API, define connections as an array of objects.

```ts Node.js {10, 15, 22} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.create({
  name: 'Welcome series',
  status: 'disabled',
  steps: [
    {
      key: 'start',
      type: 'trigger',
      config: { eventName: 'user.created' },
    },
    {
      key: 'welcome',
      type: 'send_email',
      config: {
        template: { id: '34a080c9-b17d-4187-ad80-5af20266e535' },
      },
    },
  ],
  connections: [{ from: 'start', to: 'welcome' }],
});
```

```php PHP {8,13,20} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->create([
  'name' => 'Welcome series',
  'status' => 'disabled',
  'steps' => [
    [
      'key' => 'start',
      'type' => 'trigger',
      'config' => ['event_name' => 'user.created'],
    ],
    [
      'key' => 'welcome',
      'type' => 'send_email',
      'config' => [
        'template' => ['id' => '34a080c9-b17d-4187-ad80-5af20266e535'],
      ],
    ],
  ],
  'connections' => [['from' => 'start', 'to' => 'welcome']],
]);
```

```python Python {10, 15, 22} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Automations.CreateParams = {
  "name": "Welcome series",
  "status": "disabled",
  "steps": [
    {
      "key": "start",
      "type": "trigger",
      "config": {"event_name": "user.created"},
    },
    {
      "key": "welcome",
      "type": "send_email",
      "config": {
        "template": {"id": "34a080c9-b17d-4187-ad80-5af20266e535"},
      },
    },
  ],
  "connections": [{"from": "start", "to": "welcome"}],
}

resend.Automations.create(params)
```

```ruby Ruby {10, 15, 22} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "Welcome series",
  status: "disabled",
  steps: [
    {
      key: "start",
      type: "trigger",
      config: { event_name: "user.created" },
    },
    {
      key: "welcome",
      type: "send_email",
      config: {
        template: { id: "34a080c9-b17d-4187-ad80-5af20266e535" },
      },
    },
  ],
  connections: [{ from: "start", to: "welcome" }],
}

Resend::Automations.create(params)
```

```go Go {13, 20, 30} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateAutomationRequest{
		Name:   "Welcome series",
		Status: resend.AutomationStatusDisabled,
		Steps: []resend.AutomationStep{
			{
				Key:  "start",
				Type: resend.AutomationStepTypeTrigger,
				Config: map[string]any{
					"event_name": "user.created",
				},
			},
			{
				Key:  "welcome",
				Type: resend.AutomationStepTypeSendEmail,
				Config: map[string]any{
					"template": map[string]any{
						"id": "34a080c9-b17d-4187-ad80-5af20266e535",
					},
				},
			},
		},
		Connections: []resend.AutomationConnection{
			{From: "start", To: "welcome"},
		},
	}

	client.Automations.Create(params)
}
```

```rust Rust {18, 24, 30} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{
    AutomationStatus, AutomationTemplate, Connection, CreateAutomationOptions, SendEmailStepConfig,
    Step, TriggerStepConfig,
  },
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = CreateAutomationOptions {
    name: "Welcome series".to_owned(),
    status: AutomationStatus::Disabled,
    steps: vec![
      Step::Trigger {
        key: "start".to_owned(),
        config: TriggerStepConfig {
          event_name: "user.created".to_owned(),
        },
      },
      Step::SendEmail {
        key: "welcome".to_owned(),
        config: SendEmailStepConfig::new(AutomationTemplate::new(
          "34a080c9-b17d-4187-ad80-5af20266e535",
        )),
      },
    ],
    connections: vec![Connection::new("start", "welcome")],
  };
  let _automation = resend.automations.create(opts).await?;

  Ok(())
}
```

```java Java {17,22,26-29} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.AutomationConnection;
import com.resend.services.automations.model.AutomationStatus;
import com.resend.services.automations.model.AutomationStep;
import com.resend.services.automations.model.CreateAutomationOptions;
import com.resend.services.automations.model.CreateAutomationResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateAutomationOptions options = CreateAutomationOptions.builder()
                .name("Welcome series")
                .status(AutomationStatus.DISABLED)
                .steps(
                    AutomationStep.trigger("start")
                        .eventName("user.created")
                        .build(),
                    AutomationStep.sendEmail("welcome")
                        .template("34a080c9-b17d-4187-ad80-5af20266e535")
                        .build()
                )
                .connections(
                    AutomationConnection.builder()
                        .from("start")
                        .to("welcome")
                        .build()
                )
                .build();

        CreateAutomationResponseSuccess data = resend.automations().create(options);
    }
}
```

```csharp .NET {15,16,20} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.created" } );
var welcomeConfig = JsonSerializer.SerializeToElement( new { template = new { id = "34a080c9-b17d-4187-ad80-5af20266e535" } } );

var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
{
    Name = "Welcome series",
    Status = "disabled",
    Steps = new List<AutomationStepData>
    {
        new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
        new AutomationStepData { Ref = "welcome", Type = "send_email", Config = welcomeConfig },
    },
    Connections = new List<AutomationEdge>
    {
        new AutomationEdge { From = "start", To = "welcome" },
    },
} );
```

```bash cURL {8,13,20-22} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/automations' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "name": "Welcome series",
  "steps": [
    {
      "key": "start",
      "type": "trigger",
      "config": { "event_name": "user.created" }
    },
    {
      "key": "welcome",
      "type": "send_email",
      "config": {
        "template": { "id": "34a080c9-b17d-4187-ad80-5af20266e535" }
      }
    }
  ],
  "connections": [
    { "from": "start", "to": "welcome" }
  ]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations create --name "Welcome series" --file ./automation.json
```

When retrieving Automations, the API returns the connections as an array.

```json Response {10,15,22-28} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "automation",
  "id": "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
  "name": "Welcome series",
  "status": "disabled",
  "created_at": "2026-10-01 12:00:00.000000+00",
  "updated_at": "2026-10-01 12:00:00.000000+00",
  "steps": [
    {
      "key": "start",
      "type": "trigger",
      "config": { "event_name": "user.created" }
    },
    {
      "key": "welcome",
      "type": "send_email",
      "config": {
        "template": { "id": "34a080c9-b17d-4187-ad80-5af20266e535" }
      }
    }
  ],
  "connections": [
    {
      "from": "start",
      "to": "welcome",
      "type": "default"
    }
  ]
}
```

## Connection properties

Connections define the links between steps in the automation graph.

**from** `string` *required*

This is the `key` of the origin step.

**to** `string` *required*

This is the `key` of the destination step.

**type** `string`

The type of connection between the origin and destination steps. Most
automations use the default connection type.

Use a non-default `type` only when the origin step can branch to multiple
destinations:

* For `wait_for_event`, use `event_received` or `timeout`.
* For `condition`, use `condition_met` or `condition_not_met`.

Possible values:

* `default`
* `condition_met`
* `condition_not_met`
* `timeout`
* `event_received`

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "from": "start",
  "to": "welcome",
  "type": "default"
}
```


# Contact Delete
Source: https://resend.com/docs/dashboard/automations/contact-delete

Remove a contact from your audience in an Automation.

This step removes the contact that triggered the Automation from your [Contact list](/docs/dashboard/contacts/introduction). Once deleted, the contact will no longer receive Broadcasts, and any remaining steps in the Automation run are skipped.

Common use cases:

* **Compliance**: Delete contacts as part of a data-removal workflow.
* **Churn**: Remove a contact, when a user stops using your service.
* **Unsubscribe flows**: Automatically remove contacts who opt out.

## How it works

> [tab] Using the dashboard
>
> Include the **Delete contact** step to your Automation.
>
> ![Automation Contact Delete](https://mintcdn.com/resend/GClVSBUDv2Z8C3Ae/images/automations-contact-delete.png?fit=max\&auto=format\&n=GClVSBUDv2Z8C3Ae\&q=85\&s=57ab7ffaa985a85df04deab53f9dc27a)
>
> No configuration required. It is ready as soon as you add it.

> [tab] Using the API
>
> Add a `contact_delete` step to your Automation's `steps` array.
>
> ```ts Node.js {13-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.create({
>   name: 'Remove churned users',
>   steps: [
>     {
>       key: 'start',
>       type: 'trigger',
>       config: { eventName: 'user.deleted' },
>     },
>     {
>       key: 'remove',
>       type: 'contact_delete',
>       config: {},
>     },
>   ],
>   connections: [{ from: 'start', to: 'remove', type: 'default' }],
> });
> ```
>
> ```php PHP {11-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->create([
>   'name' => 'Remove churned users',
>   'steps' => [
>     [
>       'key' => 'start',
>       'type' => 'trigger',
>       'config' => ['event_name' => 'user.deleted'],
>     ],
>     [
>       'key' => 'remove',
>       'type' => 'contact_delete',
>       'config' => [],
>     ],
>   ],
>   'connections' => [['from' => 'start', 'to' => 'remove', 'type' => 'default']],
> ]);
> ```
>
> ```python Python {13-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Automations.CreateParams = {
>   "name": "Remove churned users",
>   "steps": [
>     {
>       "key": "start",
>       "type": "trigger",
>       "config": {"event_name": "user.deleted"},
>     },
>     {
>       "key": "remove",
>       "type": "contact_delete",
>       "config": {},
>     },
>   ],
>   "connections": [{"from": "start", "to": "remove", "type": "default"}],
> }
>
> resend.Automations.create(params)
> ```
>
> ```ruby Ruby {13-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   name: "Remove churned users",
>   steps: [
>     {
>       key: "start",
>       type: "trigger",
>       config: { event_name: "user.deleted" },
>     },
>     {
>       key: "remove",
>       type: "contact_delete",
>       config: {},
>     },
>   ],
>   connections: [{ from: "start", to: "remove", type: "default" }],
> }
>
> Resend::Automations.create(params)
> ```
>
> ```go Go {18-22} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	params := &resend.CreateAutomationRequest{
> 		Name: "Remove churned users",
> 		Steps: []resend.AutomationStep{
> 			{
> 				Key:  "start",
> 				Type: resend.AutomationStepTypeTrigger,
> 				Config: map[string]any{
> 					"event_name": "user.deleted",
> 				},
> 			},
> 			{
> 				Key:    "remove",
> 				Type:   resend.AutomationStepTypeContactDelete,
> 				Config: map[string]any{},
> 			},
> 		},
> 		Connections: []resend.AutomationConnection{
> 			{From: "start", To: "remove", Type: resend.AutomationConnectionTypeDefault},
> 		},
> 	}
>
> 	client.Automations.Create(params)
> }
> ```
>
> ```rust Rust {22-25} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   json,
>   types::{
>     AutomationStatus, Connection, ConnectionType, CreateAutomationOptions, Step, TriggerStepConfig,
>   },
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let opts = CreateAutomationOptions {
>     name: "Remove churned users".to_owned(),
>     steps: vec![
>       Step::Trigger {
>         key: "start".to_owned(),
>         config: TriggerStepConfig {
>           event_name: "user.deleted".to_owned(),
>         },
>       },
>       Step::ContactDelete {
>         key: "remove".to_owned(),
>         config: json!("{}"),
>       },
>     ],
>     connections: vec![Connection::new("start", "remove").with_type(ConnectionType::Default)],
>     status: AutomationStatus::Disabled,
>   };
>   let _automation = resend.automations.create(opts).await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {20-23} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.AutomationConnection;
> import com.resend.services.automations.model.AutomationStep;
> import com.resend.services.automations.model.ConnectionType;
> import com.resend.services.automations.model.CreateAutomationOptions;
> import com.resend.services.automations.model.CreateAutomationResponseSuccess;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         CreateAutomationOptions options = CreateAutomationOptions.builder()
>                 .name("Remove churned users")
>                 .steps(
>                     AutomationStep.trigger("start")
>                         .eventName("user.deleted")
>                         .build(),
>                     AutomationStep.contactDelete("remove")
>                         .build()
>                 )
>                 .connections(
>                     AutomationConnection.builder()
>                         .from("start")
>                         .to("remove")
>                         .type(ConnectionType.DEFAULT)
>                         .build()
>                 )
>                 .build();
>
>         CreateAutomationResponseSuccess data = resend.automations().create(options);
>     }
> }
> ```
>
> ```csharp .NET {7,15} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.deleted" } );
> var removeConfig = JsonSerializer.SerializeToElement( new { } );
>
> var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
> {
>     Name = "Remove churned users",
>     Steps = new List<AutomationStepData>
>     {
>         new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
>         new AutomationStepData { Ref = "remove", Type = "contact_delete", Config = removeConfig },
>     },
>     Connections = new List<AutomationEdge>
>     {
>         new AutomationEdge { From = "start", To = "remove", EdgeType = "default" },
>     },
> } );
> ```
>
> ```bash cURL {10-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/automations' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "name": "Remove churned users",
>   "steps": [{
>     "key": "start",
>     "type": "trigger",
>     "config": { "event_name": "user.deleted" }
>   }, {
>     "key": "remove",
>     "type": "contact_delete",
>     "config": {}
>   }],
>   "connections": [
>     { "from": "start", "to": "remove", "type": "default" }
>   ]
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations create --name "Remove churned users" --file ./automation.json
> ```
>
> The `config` object is empty, so no additional fields are required.

> [!WARNING]
>
> Deleting a contact is **permanent**. The contact and all of its properties are
> removed from the audience. If the contact needs to be re-added later, it must
> be created again.

## Configuration

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "remove_contact",
  "type": "contact_delete",
  "config": {}
}
```


# Contact Update
Source: https://resend.com/docs/dashboard/automations/contact-update

Update contact fields during an Automation.

The contact update step modifies a contact's fields as part of an Automation. You can update a contact's name, subscription status, or custom properties.

Common use cases:

* **Enrich profiles**: Copy event data into the contact record.
* **Set flags**: Mark contacts as VIP, or churned based on their activity.
* **Sync properties**: Keep custom properties up to date as events flow in.

## How it works

> [tab] Using the dashboard
>
> Add an **Update contact** step and update the fields you want to change.
>
> ![Automation Contact Update](https://mintcdn.com/resend/EZ0xKskHBx2vJji1/images/automations-contact-update.png?fit=max\&auto=format\&n=EZ0xKskHBx2vJji1\&q=85\&s=b1cc46666d2ed553189edc9952d7649e)

> [tab] Using the API
>
> Add a `contact_update` step to your Automation's `steps` array.
>
> ```ts Node.js {13-24} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.create({
>   name: 'Enrich contact on signup',
>   steps: [
>     {
>       key: 'start',
>       type: 'trigger',
>       config: { eventName: 'user.created' },
>     },
>     {
>       key: 'update',
>       type: 'contact_update',
>       config: {
>         firstName: { var: 'event.firstName' },
>         lastName: { var: 'event.lastName' },
>         properties: {
>           company: { var: 'event.company' },
>           vip: true,
>         },
>       },
>     },
>   ],
>   connections: [{ from: 'start', to: 'update', type: 'default' }],
> });
> ```
>
> ```php PHP {11-22} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->create([
>   'name' => 'Enrich contact on signup',
>   'steps' => [
>     [
>       'key' => 'start',
>       'type' => 'trigger',
>       'config' => ['event_name' => 'user.created'],
>     ],
>     [
>       'key' => 'update',
>       'type' => 'contact_update',
>       'config' => [
>         'first_name' => ['var' => 'event.firstName'],
>         'last_name' => ['var' => 'event.lastName'],
>         'properties' => [
>           'company' => ['var' => 'event.company'],
>           'vip' => true,
>         ],
>       ],
>     ],
>   ],
>   'connections' => [['from' => 'start', 'to' => 'update', 'type' => 'default']],
> ]);
> ```
>
> ```python Python {13-24} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Automations.CreateParams = {
>   "name": "Enrich contact on signup",
>   "steps": [
>     {
>       "key": "start",
>       "type": "trigger",
>       "config": {"event_name": "user.created"},
>     },
>     {
>       "key": "update",
>       "type": "contact_update",
>       "config": {
>         "first_name": {"var": "event.firstName"},
>         "last_name": {"var": "event.lastName"},
>         "properties": {
>           "company": {"var": "event.company"},
>           "vip": True,
>         },
>       },
>     },
>   ],
>   "connections": [{"from": "start", "to": "update", "type": "default"}],
> }
>
> resend.Automations.create(params)
> ```
>
> ```ruby Ruby {13-24} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   name: "Enrich contact on signup",
>   steps: [
>     {
>       key: "start",
>       type: "trigger",
>       config: { event_name: "user.created" },
>     },
>     {
>       key: "update",
>       type: "contact_update",
>       config: {
>         first_name: { var: "event.firstName" },
>         last_name: { var: "event.lastName" },
>         properties: {
>           company: { var: "event.company" },
>           vip: true,
>         },
>       },
>     },
>   ],
>   connections: [{ from: "start", to: "update", type: "default" }],
> }
>
> Resend::Automations.create(params)
> ```
>
> ```go Go {18-29} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	params := &resend.CreateAutomationRequest{
> 		Name: "Enrich contact on signup",
> 		Steps: []resend.AutomationStep{
> 			{
> 				Key:  "start",
> 				Type: resend.AutomationStepTypeTrigger,
> 				Config: map[string]any{
> 					"event_name": "user.created",
> 				},
> 			},
> 			{
> 				Key:  "update",
> 				Type: resend.AutomationStepTypeContactUpdate,
> 				Config: map[string]any{
> 					"first_name": map[string]any{"var": "event.firstName"},
> 					"last_name":  map[string]any{"var": "event.lastName"},
> 					"properties": map[string]any{
> 						"company": map[string]any{"var": "event.company"},
> 						"vip":     true,
> 					},
> 				},
> 			},
> 		},
> 		Connections: []resend.AutomationConnection{
> 			{From: "start", To: "update", Type: resend.AutomationConnectionTypeDefault},
> 		},
> 	}
>
> 	client.Automations.Create(params)
> }
> ```
>
> ```rust Rust {22-32} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   json,
>   types::{
>     AutomationStatus, Connection, ConnectionType, CreateAutomationOptions, Step, TriggerStepConfig,
>   },
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let opts = CreateAutomationOptions {
>     name: "Enrich contact on signup".to_owned(),
>     steps: vec![
>       Step::Trigger {
>         key: "start".to_owned(),
>         config: TriggerStepConfig {
>           event_name: "user.created".to_owned(),
>         },
>       },
>       Step::ContactUpdate {
>         key: "update".to_owned(),
>         config: json!({
>           "firstName": {"var": "event.firstName"},
>           "lastName": {"var": "event.lastName"},
>           "properties": {
>             "company": {"var": "event.company"},
>             "vip": true
>           }
>         }),
>       },
>     ],
>     connections: vec![Connection::new("start", "update").with_type(ConnectionType::Default)],
>     status: AutomationStatus::Disabled,
>   };
>   let _automation = resend.automations.create(opts).await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {21-29} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.AutomationConnection;
> import com.resend.services.automations.model.AutomationStep;
> import com.resend.services.automations.model.ConnectionType;
> import com.resend.services.automations.model.CreateAutomationOptions;
> import com.resend.services.automations.model.CreateAutomationResponseSuccess;
> import java.util.Map;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         CreateAutomationOptions options = CreateAutomationOptions.builder()
>                 .name("Enrich contact on signup")
>                 .steps(
>                     AutomationStep.trigger("start")
>                         .eventName("user.created")
>                         .build(),
>                     AutomationStep.contactUpdate("update")
>                         .firstName(Map.of("var", "event.firstName"))
>                         .lastName(Map.of("var", "event.lastName"))
>                         .properties(Map.of(
>                                 "company", Map.of("var", "event.company"),
>                                 "vip", true))
>                         .build()
>                 )
>                 .connections(
>                     AutomationConnection.builder()
>                         .from("start")
>                         .to("update")
>                         .type(ConnectionType.DEFAULT)
>                         .build()
>                 )
>                 .build();
>
>         CreateAutomationResponseSuccess data = resend.automations().create(options);
>     }
> }
> ```
>
> ```csharp .NET {7-16,24} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.created" } );
> var updateConfig = JsonSerializer.SerializeToElement( new
> {
>     first_name = new { @var = "event.firstName" },
>     last_name = new { @var = "event.lastName" },
>     properties = new
>     {
>         company = new { @var = "event.company" },
>         vip = true,
>     },
> } );
>
> var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
> {
>     Name = "Enrich contact on signup",
>     Steps = new List<AutomationStepData>
>     {
>         new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
>         new AutomationStepData { Ref = "update", Type = "contact_update", Config = updateConfig },
>     },
>     Connections = new List<AutomationEdge>
>     {
>         new AutomationEdge { From = "start", To = "update", EdgeType = "default" },
>     },
> } );
> ```
>
> ```bash cURL {10-21} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/automations' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "name": "Enrich contact on signup",
>   "steps": [{
>     "key": "start",
>     "type": "trigger",
>     "config": { "event_name": "user.created" }
>   }, {
>     "key": "update",
>     "type": "contact_update",
>     "config": {
>       "first_name": { "var": "event.firstName" },
>       "last_name": { "var": "event.lastName" },
>       "properties": {
>         "company": { "var": "event.company" },
>         "vip": true
>       }
>     }
>   }],
>   "connections": [
>     { "from": "start", "to": "update", "type": "default" }
>   ]
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations create --name "Enrich contact on signup" --file ./automation.json
> ```

## Dynamic variables

Each field value is a fixed value (string, number, or boolean), or a reference with `{ "var": "<path>" }`:

* `event.*` is a field from the event that triggered the Automation, such as `event.firstName`.
* `contact.*` is a field from the contact, such as `contact.properties.company`.
* `wait_events.<event_name>.*` is a field from an event a previous [wait for event](/docs/dashboard/automations/wait-for-event#use-the-received-event-in-later-steps) step received. If the Automation waited for that event more than once, this is the most recent one before this step.

For more help working with variables in templates, see the [Send Email](/docs/dashboard/automations/send-email#template-variables) step documentation.

```json {5-6,8} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "update",
  "type": "contact_update",
  "config": {
    "first_name": { "var": "event.firstName" },
    "last_name": { "var": "event.lastName" },
    "properties": {
      "company": { "var": "event.company" },
      "vip": true
    }
  }
}
```

## Configuration

**config.first\_name** `string | object`

The contact's first name. Accepts a hardcoded string or a variable reference.

**config.last\_name** `string | object`

The contact's last name. Accepts a hardcoded string or a variable reference.

**config.unsubscribed** `boolean | object`

The contact's unsubscribed status. Accepts a boolean or a variable reference.

**config.properties** `object`

A map of custom contact properties to update. Keys correspond to your [Contact
Custom Properties](/docs/dashboard/audiences/properties). Each value can be a
hardcoded value (string, number, boolean) or a variable reference.

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "update_contact",
  "type": "contact_update",
  "config": {
    "properties": {
      "company": { "var": "event.company" },
      "vip": true
    }
  }
}
```


# Create Automations
Source: https://resend.com/docs/dashboard/automations/create-automation

Create an automation triggered by an event in your application.

The following examples show how to create an automation triggered by the creation of a new user that sends them a welcome email.

## Using the dashboard

**1. Navigate to the Automations Dashboard Page**

The [Automations page](https://resend.com/automations) shows all of your existing automations, and allows you to add new ones.

**2. Click the Create automation button**

![Create Automation](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-create.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=14adc9d8a15b8c52b9b7acc361b966f2)

**3. Add Trigger**

A trigger is the first step that will run when the Automation is executed. You can create a new [custom trigger event](/docs/dashboard/automations/custom-events) when you create your automation, or select from existing events.

Your existing trigger events are available in the [Events tab of the Automation Dashboard page](https://resend.com/automations/events). You can also create new custom events on that page.

Choose a name for your custom event to describe the action that will trigger your automation. A conventional pattern is `entity.action`, like `user.created` or `onboarding.completed`.

![Add Trigger to Automation](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-trigger.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=1249bd18fbe832abb5b3ea0ecfe2b7ed)

In this example, the application will receive an event called `user.created` as a trigger.

![Add Custom Event](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-custom-event.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=4e5b189cb756d8ca5a468746dac901a0)

See the [Trigger documentation](/docs/dashboard/automations/trigger) for more details.

**4. Define Steps**

Next, define the steps that will be executed when your automation is triggered by a custom event.

There are several step types you can add to your Automation:

| Step type | Description |
| - | - |
| [Condition](/docs/dashboard/automations/condition) | Branches the workflow based on rules |
| [Delay](/docs/dashboard/automations/delay) | Pauses execution for a specified duration |
| [Wait for Event](/docs/dashboard/automations/wait-for-event) | Pauses execution until a specific event is received |
| [Send Email](/docs/dashboard/automations/send-email) | Sends an email using a template |
| [Contact Update](/docs/dashboard/automations/contact-update) | Updates a contact's fields |
| [Contact Delete](/docs/dashboard/automations/contact-delete) | Deletes the contact |
| [Add to Segment](/docs/dashboard/automations/add-to-segment) | Adds the contact to a segment |

This example will send an email when a user is created.

![Define Steps](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-steps.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=270948146f144b3a6108cd99c81d7a70)

Once you select that step, you will be able to select an existing email Template.

> [!NOTE]
>
> Note: Only [`published`
> Templates](/docs/dashboard/templates/version-history#draft-vs-published) can be
> used in an Automation.

![Add Send Email Step](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-steps-email.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=98e94d53506699d565747e510702ad53)

With the Template selected, you will be able to configure the email subject and sender address.

![Send Email Step Settings](https://mintcdn.com/resend/3_DkZ6MFMzztlC_E/images/automations-steps-email-settings.png?fit=max\&auto=format\&n=3_DkZ6MFMzztlC_E\&q=85\&s=312f80d13ca502ae8de7e7bffd31e251)

Once you're done with the email, you can click on **Start** to enable the Automation.

![Automation Enabled](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-enabled.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=09a441d2dce12d317b177fb9ede7dea0)

> [!NOTE]
>
> While an Automation is enabled, its steps cannot be edited. To make changes,
> [duplicate the Automation](/docs/api-reference/automations/duplicate-automation),
> edit the copy, and switch over by stopping new runs on the original. In-flight
> runs will carry out the existing Automation in place when they started.

**5. Send an Event**

In your application, send an event to trigger the Automation with the Send Event API. Include your custom event name and either `contact_id` or `email`.

You can optionally include a `payload` object containing custom data to pass to the automation.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

// Trigger with a contact ID
const { data, error } = await resend.events.send({
  event: 'user.created',
  contactId: '7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b',
  // or: email: 'steve.wozniak@gmail.com',
  payload: {
    plan: 'pro',
  },
});
```

```php PHP {6,13} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Trigger with a contact ID
$resend->events->send([
  'event' => 'user.created',
  'contact_id' => '7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b',
  'payload' => ['plan' => 'pro'],
]);

// Trigger with an email address
$resend->events->send([
  'event' => 'user.created',
  'email' => 'steve.wozniak@gmail.com',
  'payload' => ['plan' => 'pro'],
]);
```

```python Python {8,19} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Trigger with a contact ID
params: resend.Events.SendParams = {
  "event": "user.created",
  "contact_id": "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
  "payload": {
    "plan": "pro",
  },
}

resend.Events.send(params)

# Trigger with an email address
params: resend.Events.SendParams = {
  "event": "user.created",
  "email": "steve.wozniak@gmail.com",
  "payload": {
    "plan": "pro",
  },
}

resend.Events.send(params)
```

```ruby Ruby {8,17} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Trigger with a contact ID
params = {
  event: "user.created",
  contact_id: "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
  payload: {
    plan: "pro",
  },
}

Resend::Events.send(params)

# Trigger with an email address
params = {
  event: "user.created",
  email: "steve.wozniak@gmail.com",
  payload: {
    plan: "pro",
  },
}

Resend::Events.send(params)
```

```go Go {11,20} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
  client := resend.NewClient("re_xxxxxxxxx")

  // Trigger with a contact ID
  client.Events.Send(&resend.SendEventRequest{
    Event:     "user.created",
    ContactId: "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
    Payload: map[string]any{
      "plan": "pro",
    },
  })

  // Trigger with an email address
  client.Events.Send(&resend.SendEventRequest{
    Event: "user.created",
    Email: "steve.wozniak@gmail.com",
    Payload: map[string]any{
      "plan": "pro",
    },
  })
}
```

```rust Rust {16-18,28} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  json,
  types::{ContactIdOrEmail, SendEventOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  // Trigger with a contact ID
  let _event = resend
    .events
    .send(SendEventOptions {
      event: "user.created".to_owned(),
      contact_id_or_email: ContactIdOrEmail::ContactId(
        "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b".to_owned(),
      ),
      payload: json!({ "plan": "pro" }),
    })
    .await?;

  // Trigger with an email address
  let _event = resend
    .events
    .send(SendEventOptions {
      event: "user.created".to_owned(),
      contact_id_or_email: ContactIdOrEmail::Email("steve.wozniak@gmail.com".to_owned()),
      payload: json!({ "plan": "pro" }),
    })
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.SendEventOptions;
import com.resend.services.events.model.SendEventResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        // Trigger with a contact ID
        SendEventOptions params = SendEventOptions.builder()
                .event("user.created")
                .contactId("7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b")
                .addPayload("plan", "pro")
                .build();

        SendEventResponseSuccess data = resend.events().send(params);

        // Trigger with an email address
        SendEventOptions params2 = SendEventOptions.builder()
                .event("user.created")
                .email("steve.wozniak@gmail.com")
                .addPayload("plan", "pro")
                .build();

        SendEventResponseSuccess data2 = resend.events().send(params2);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var payload = JsonSerializer.SerializeToElement( new { plan = "pro" } );

// Trigger with a contact ID
var resp = await resend.EventSendAsync( new EventSendData()
{
    Event = "user.created",
    ContactId = new Guid( "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b" ),
    Payload = payload,
} );
Console.WriteLine( "Event={0}", resp.Content.Event );

// Trigger with an email address
await resend.EventSendAsync( new EventSendData()
{
    Event = "user.created",
    Email = "steve.wozniak@gmail.com",
    Payload = payload,
} );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Trigger with a contact ID
curl -X POST 'https://api.resend.com/events/send' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json' \
    -d '{
  "event": "user.created",
  "contact_id": "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
  "payload": {
    "plan": "pro"
  }
}'

# Trigger with an email address
curl -X POST 'https://api.resend.com/events/send' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json' \
    -d '{
  "event": "user.created",
  "email": "steve.wozniak@gmail.com",
  "payload": {
    "plan": "pro"
  }
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Trigger with a contact ID
resend events send \
  --event user.created \
  --contact-id 7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b \
  --payload '{"plan":"pro"}'

# Trigger with an email address
resend events send \
  --event user.created \
  --email steve.wozniak@gmail.com \
  --payload '{"plan":"pro"}'
```

View the [Send Event API reference](/docs/api-reference/events/send-event) for more details.

**6. Monitor Runs**

After sending events, you can monitor your Automation executions through Runs. Each time an event triggers an Automation, a Run is created to track the execution.

![Monitor Runs](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-runs.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=b15322c27ffd309ee310250f6fc6dedd)

See the [Runs documentation](/docs/dashboard/automations/runs) to learn how to:

* View Run statuses and execution details
* Filter Runs by status (`running`, `completed`, `failed`, `cancelled`)
* Debug failed Runs with step-level error information
* Stop Automation Runs when needed

## Using the API

When creating an Automation via the API, you can create an entire Automation flow with a single request.

**1. Define Trigger**

Automations are triggered by a custom event. Choose a name like `user.created` or `onboarding.completed` for your custom event to describe the action that will trigger your automation.

If you want to define a schema for the event's properties, create the event in the [Events tab of the Automation Dashboard page](https://resend.com/automations/events) or with the [Create Event API](/docs/api-reference/events/create-event). The schema validates the payload when the event is sent and makes the event's properties available to fill in variables in later steps.

**2. Define Automation**

The Create Automation API accepts four parameters (status is optional and defaults to `disabled`):

* `name`: The name of the Automation.
* `status`: The status of the Automation.
* `steps`: The [steps](/docs/dashboard/automations/steps) that compose the Automation graph. Use your custom event name as the first item in the `steps` array with `type: 'trigger'`.
* `connections`: The [connections between steps](/docs/dashboard/automations/connections) in the Automation graph.

**3. Create Automation**

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.create({
  name: 'Welcome series',
  status: 'disabled',
  steps: [
    {
      key: 'start',
      type: 'trigger',
      config: { eventName: 'user.created' },
    },
    {
      key: 'welcome',
      type: 'send_email',
      config: {
        template: { id: '34a080c9-b17d-4187-ad80-5af20266e535' },
      },
    },
  ],
  connections: [{ from: 'start', to: 'welcome' }],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->create([
  'name' => 'Welcome series',
  'status' => 'disabled',
  'steps' => [
    [
      'key' => 'start',
      'type' => 'trigger',
      'config' => ['event_name' => 'user.created'],
    ],
    [
      'key' => 'welcome',
      'type' => 'send_email',
      'config' => [
        'template' => ['id' => '34a080c9-b17d-4187-ad80-5af20266e535'],
      ],
    ],
  ],
  'connections' => [['from' => 'start', 'to' => 'welcome']],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Automations.CreateParams = {
  "name": "Welcome series",
  "status": "disabled",
  "steps": [
    {
      "key": "start",
      "type": "trigger",
      "config": {"event_name": "user.created"},
    },
    {
      "key": "welcome",
      "type": "send_email",
      "config": {
        "template": {"id": "34a080c9-b17d-4187-ad80-5af20266e535"},
      },
    },
  ],
  "connections": [{"from": "start", "to": "welcome"}],
}

resend.Automations.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "Welcome series",
  status: "disabled",
  steps: [
    {
      key: "start",
      type: "trigger",
      config: { event_name: "user.created" },
    },
    {
      key: "welcome",
      type: "send_email",
      config: {
        template: { id: "34a080c9-b17d-4187-ad80-5af20266e535" },
      },
    },
  ],
  connections: [{ from: "start", to: "welcome" }],
}

Resend::Automations.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateAutomationRequest{
    Name:   "Welcome series",
    Status: resend.AutomationStatusDisabled,
    Steps: []resend.AutomationStep{
      {
        Key:  "start",
        Type: resend.AutomationStepTypeTrigger,
        Config: map[string]any{
          "event_name": "user.created",
        },
      },
      {
        Key:  "welcome",
        Type: resend.AutomationStepTypeSendEmail,
        Config: map[string]any{
          "template": map[string]any{
            "id": "34a080c9-b17d-4187-ad80-5af20266e535",
          },
        },
      },
    },
    Connections: []resend.AutomationConnection{
      {From: "start", To: "welcome"},
    },
  }

  client.Automations.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{
    AutomationStatus, AutomationTemplate, Connection, CreateAutomationOptions, SendEmailStepConfig,
    Step, TriggerStepConfig,
  },
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = CreateAutomationOptions {
    name: "Welcome series".to_owned(),
    status: AutomationStatus::Disabled,
    steps: vec![
      Step::Trigger {
        key: "start".to_owned(),
        config: TriggerStepConfig {
          event_name: "user.created".to_owned(),
        },
      },
      Step::SendEmail {
        key: "welcome".to_owned(),
        config: SendEmailStepConfig::new(AutomationTemplate::new(
          "34a080c9-b17d-4187-ad80-5af20266e535",
        )),
      },
    ],
    connections: vec![Connection::new("start", "welcome")],
  };
  let _automation = resend.automations.create(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.AutomationConnection;
import com.resend.services.automations.model.AutomationStatus;
import com.resend.services.automations.model.AutomationStep;
import com.resend.services.automations.model.CreateAutomationOptions;
import com.resend.services.automations.model.CreateAutomationResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateAutomationOptions options = CreateAutomationOptions.builder()
                .name("Welcome series")
                .status(AutomationStatus.DISABLED)
                .steps(
                    AutomationStep.trigger("start")
                        .eventName("user.created")
                        .build(),
                    AutomationStep.sendEmail("welcome")
                        .template("34a080c9-b17d-4187-ad80-5af20266e535")
                        .build()
                )
                .connections(
                    AutomationConnection.builder()
                        .from("start")
                        .to("welcome")
                        .build()
                )
                .build();

        CreateAutomationResponseSuccess response = resend.automations().create(options);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.created" } );
var welcomeConfig = JsonSerializer.SerializeToElement( new { template = new { id = "34a080c9-b17d-4187-ad80-5af20266e535" } } );

var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
{
    Name = "Welcome series",
    Status = "disabled",
    Steps = new List<AutomationStepData>
    {
        new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
        new AutomationStepData { Ref = "welcome", Type = "send_email", Config = welcomeConfig },
    },
    Connections = new List<AutomationEdge>
    {
        new AutomationEdge { From = "start", To = "welcome" },
    },
} );
Console.WriteLine( "AutomationId={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/automations' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json' \
    -d '{
  "name": "Welcome series",
  "steps": [
    {
      "key": "start",
      "type": "trigger",
      "config": { "event_name": "user.created" }
    },
    {
      "key": "welcome",
      "type": "send_email",
      "config": {
        "template": { "id": "34a080c9-b17d-4187-ad80-5af20266e535" }
      }
    }
  ],
  "connections": [
    { "from": "start", "to": "welcome" }
  ]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations create --name "Welcome series" --file ./automation.json
```

For more help creating an Automation via the API, see the [Create Automation API reference](/docs/api-reference/automations/create-automation).

**4. Send an Event**

Trigger the Automation by sending an event from your application.

```ts Node.js {8-9} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

// Trigger with a contact ID
const { data, error } = await resend.events.send({
  event: 'user.created',
  contactId: '7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b',
  // or: email: 'steve.wozniak@gmail.com',
  payload: {
    plan: 'pro',
  },
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Trigger with a contact ID
$resend->events->send([
  'event' => 'user.created',
  'contact_id' => '7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b',
  'payload' => ['plan' => 'pro'],
]);

// Trigger with an email address
$resend->events->send([
  'event' => 'user.created',
  'email' => 'steve.wozniak@gmail.com',
  'payload' => ['plan' => 'pro'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Trigger with a contact ID
params: resend.Events.SendParams = {
  "event": "user.created",
  "contact_id": "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
  "payload": {
    "plan": "pro",
  },
}

resend.Events.send(params)

# Trigger with an email address
params: resend.Events.SendParams = {
  "event": "user.created",
  "email": "steve.wozniak@gmail.com",
  "payload": {
    "plan": "pro",
  },
}

resend.Events.send(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Trigger with a contact ID
params = {
  event: "user.created",
  contact_id: "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
  payload: {
    plan: "pro",
  },
}

Resend::Events.send(params)

# Trigger with an email address
params = {
  event: "user.created",
  email: "steve.wozniak@gmail.com",
  payload: {
    plan: "pro",
  },
}

Resend::Events.send(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
  client := resend.NewClient("re_xxxxxxxxx")

  // Trigger with a contact ID
  params := &resend.SendEventRequest{
    Event:     "user.created",
    ContactId: "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
    Payload: map[string]any{
      "plan": "pro",
    },
  }

  client.Events.Send(params)

  // Trigger with an email address
  params = &resend.SendEventRequest{
    Event: "user.created",
    Email: "steve.wozniak@gmail.com",
    Payload: map[string]any{
      "plan": "pro",
    },
  }

  client.Events.Send(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  json,
  types::{ContactIdOrEmail, SendEventOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = SendEventOptions {
    event: "user.created".to_owned(),
    contact_id_or_email: ContactIdOrEmail::ContactId(
      "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b".to_owned(),
    ),
    // or: ContactIdOrEmail::Email("steve.wozniak@gmail.com".to_owned())
    payload: json!({
      "plan": "pro"
    }),
  };

  let _event = resend.events.send(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.SendEventOptions;
import com.resend.services.events.model.SendEventResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        SendEventOptions params = SendEventOptions.builder()
                .event("user.created")
                .contactId("7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b") // or: .email("steve.wozniak@gmail.com")
                .addPayload("plan", "pro")
                .build();

        SendEventResponseSuccess data = resend.events().send(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var payload = JsonSerializer.SerializeToElement( new { plan = "pro" } );

// Trigger with a contact ID
var resp = await resend.EventSendAsync( new EventSendData()
{
    Event = "user.created",
    ContactId = new Guid( "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b" ),
    Payload = payload,
} );
Console.WriteLine( "Event={0}", resp.Content.Event );

// Trigger with an email address
await resend.EventSendAsync( new EventSendData()
{
    Event = "user.created",
    Email = "steve.wozniak@gmail.com",
    Payload = payload,
} );
```

```bash cURL {7,19} theme={"theme":{"light":"github-light","dark":"vesper"}}
# Trigger with a contact ID
curl -X POST 'https://api.resend.com/events/send' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json' \
    -d '{
  "event": "user.created",
  "contact_id": "7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b",
  "payload": {
    "plan": "pro"
  }
}'

# Trigger with an email address
curl -X POST 'https://api.resend.com/events/send' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json' \
    -d '{
  "event": "user.created",
  "email": "steve.wozniak@gmail.com",
  "payload": {
    "plan": "pro"
  }
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Trigger with a contact ID
resend events send \
  --event user.created \
  --contact-id 7f2e4a3b-dfbc-4e9a-8b2c-5f3a1d6e7c8b \
  --payload '{"plan":"pro"}'

# Trigger with an email address
resend events send \
  --event user.created \
  --email steve.wozniak@gmail.com \
  --payload '{"plan":"pro"}'
```

View the [Send Event API reference](/docs/api-reference/events/send-event) for more details.

**5. Monitor Runs**

After sending events, track your Automation executions through Runs.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.automations.runs.list({
  automationId: 'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->automations->runs->list('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Automations.Runs.list("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Automations::Runs.list("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
  client := resend.NewClient("re_xxxxxxxxx")

  client.Automations.ListRuns("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _automation = resend
    .automations
    .list_runs(
      "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
      None,
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.automations.model.ListAutomationRunsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListAutomationRunsResponseSuccess data = resend.automations().listRuns("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.AutomationRunListAsync( new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ) );
Console.WriteLine( "Count={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/runs' \
    -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend automations runs list c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd
```

You can filter Runs by status (`running`, `completed`, `failed`, `cancelled`).

See the [Runs documentation](/docs/dashboard/automations/runs) and [List Runs API reference](/docs/api-reference/automations/list-automation-runs) for more details.

## API Reference

For complete API documentation, see the [Automations API reference](/docs/api-reference/automations/create-automation) and the [Events API reference](/docs/api-reference/events/create-event).


# Custom Events
Source: https://resend.com/docs/dashboard/automations/custom-events

Define custom events to trigger Automations.

Custom events are used to trigger automations and can be defined with an optional schema for payload validation.

If a schema is defined, payloads are validated when the event is sent. Fields that don't match the expected type are rejected with a `422` error and the event is not delivered.

## Using the dashboard

**1. Navigate to the Events Page**

The [Events page](https://resend.com/automations/events) shows all existing events.

**2. Click the Add Event button**

Click **Add event** to create a new event.

**3. Enter Event Details**

Enter the event name and optional schema to define the event payload you will send with the event.

![Add Event](https://mintcdn.com/resend/E1A_mIS7WXd7DcrQ/images/event-schema.png?fit=max\&auto=format\&n=E1A_mIS7WXd7DcrQ\&q=85\&s=0c149d67d88b9aab4fff18dbc150b286)

> [!NOTE]
>
> The event name can be any string (e.g., `user.created`, `welcome`,
> `my-custom-event`). Dot notation is a recommended convention but is not
> required. If multiple enabled automations use the same event name, all of them
> will be triggered.

**4. Save the Event**

When you're done, **Save** the event.

## Using the API

All existing events can be retrieved using the [List Events API](/docs/api-reference/events/list-events).

To create a new event, use the [Create Event API](/docs/api-reference/events/create-event) and provide an event name and optional schema.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.events.create({
  name: 'user.created',
  schema: {
    plan: 'string',
  },
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->events->create([
  'name' => 'user.created',
  'schema' => ['plan' => 'string'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Events.CreateParams = {
  "name": "user.created",
  "schema": {
    "plan": "string",
  },
}

resend.Events.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "user.created",
  schema: {
    plan: "string",
  },
}

Resend::Events.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateEventRequest{
		Name: "user.created",
		Schema: map[string]string{
			"plan": resend.EventSchemaTypeString,
		},
	}

	client.Events.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{json, types::CreateEventOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts = CreateEventOptions {
    name: "user.created".to_owned(),
    schema: json!({
      "plan": "string",
    }),
  };

  let _event = resend.events.create(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.CreateEventOptions;
import com.resend.services.events.model.CreateEventResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEventOptions params = CreateEventOptions.builder()
                .name("user.created")
                .addSchema("plan", "string")
                .build();

        CreateEventResponseSuccess data = resend.events().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var schema = JsonSerializer.SerializeToElement( new { plan = "string" } );

var resp = await resend.EventCreateAsync( new EventCreateData()
{
    Name = "user.created",
    Schema = schema,
} );
Console.WriteLine( "EventId={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/events' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "name": "user.created",
  "schema": {
    "plan": "string"
  }
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend events create --name user.created --schema '{"plan":"string"}'
```

> [!NOTE]
>
> The event name can be any string (e.g., `user.created`, `welcome`,
> `my-custom-event`). Dot notation is a recommended convention but is not
> required. If multiple enabled automations use the same event name, all of
> them will be triggered.

View the [Create Event API reference](/docs/api-reference/events/create-event) for the full endpoint specification.

## Configuration

**config.name** `string` *required*

The name of the custom event to create. Used to match events to automation triggers.

> [!WARNING]
>
> Event names cannot start with the `resend:` prefix, which is reserved for system events.

**config.schema** `object`

An optional schema definition for the event payload. Must be an object with
flat key/type pairs. Supported types: `string`, `number`, `boolean`, `date`.

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "schema": {
    "plan": "string",
    "amount": "number",
    "date": "date",
    "is_active": "boolean"
  }
}
```


# Delay
Source: https://resend.com/docs/dashboard/automations/delay

Pause your Automations with time delays.

A delay step pauses the Automation for a specified duration before continuing to the next step.

Common use cases:

* **Email sequences**: Space out emails in an onboarding series.
* **Cooldowns**: Prevent sending too many emails in a short period.
* **Follow-ups**: Give users time to take action before sending a reminder.

## How it works

> [tab] Using the dashboard
>
> You can configure a "Time Delay" duration using natural language.
>
> ![Automation](https://mintcdn.com/resend/Y9mMKs1rmWrCoGo6/images/automations-time-delay.png?fit=max\&auto=format\&n=Y9mMKs1rmWrCoGo6\&q=85\&s=fac7798f7151f7dd5862dc814f343f98)

> [tab] Using the API
>
> The delay step accepts a single `duration` field with a human-readable time value.
>
> ```ts Node.js {13-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.create({
>   name: 'Welcome Series',
>   steps: [
>     {
>       key: 'start',
>       type: 'trigger',
>       config: { eventName: 'user.created' },
>     },
>     {
>       key: 'wait_1_day',
>       type: 'delay',
>       config: { duration: '1 day' },
>     },
>   ],
>   connections: [{ from: 'start', to: 'wait_1_day', type: 'default' }],
> });
> ```
>
> ```php PHP {11-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->create([
>   'name' => 'Welcome Series',
>   'steps' => [
>     [
>       'key' => 'start',
>       'type' => 'trigger',
>       'config' => ['event_name' => 'user.created'],
>     ],
>     [
>       'key' => 'wait_1_day',
>       'type' => 'delay',
>       'config' => ['duration' => '1 day'],
>     ],
>   ],
>   'connections' => [['from' => 'start', 'to' => 'wait_1_day', 'type' => 'default']],
> ]);
> ```
>
> ```python Python {13-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Automations.CreateParams = {
>   "name": "Welcome Series",
>   "steps": [
>     {
>       "key": "start",
>       "type": "trigger",
>       "config": {"event_name": "user.created"},
>     },
>     {
>       "key": "wait_1_day",
>       "type": "delay",
>       "config": {"duration": "1 day"},
>     },
>   ],
>   "connections": [{"from": "start", "to": "wait_1_day", "type": "default"}],
> }
>
> resend.Automations.create(params)
> ```
>
> ```ruby Ruby {13-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   name: "Welcome Series",
>   steps: [
>     {
>       key: "start",
>       type: "trigger",
>       config: { event_name: "user.created" },
>     },
>     {
>       key: "wait_1_day",
>       type: "delay",
>       config: { duration: "1 day" },
>     },
>   ],
>   connections: [{ from: "start", to: "wait_1_day", type: "default" }],
> }
>
> Resend::Automations.create(params)
> ```
>
> ```go Go {18-24} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	params := &resend.CreateAutomationRequest{
> 		Name: "Welcome Series",
> 		Steps: []resend.AutomationStep{
> 			{
> 				Key:  "start",
> 				Type: resend.AutomationStepTypeTrigger,
> 				Config: map[string]any{
> 					"event_name": "user.created",
> 				},
> 			},
> 			{
> 				Key:  "wait_1_day",
> 				Type: resend.AutomationStepTypeDelay,
> 				Config: map[string]any{
> 					"duration": "1 day",
> 				},
> 			},
> 		},
> 		Connections: []resend.AutomationConnection{
> 			{From: "start", To: "wait_1_day", Type: resend.AutomationConnectionTypeDefault},
> 		},
> 	}
>
> 	client.Automations.Create(params)
> }
> ```
>
> ```rust Rust {22-27} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   types::{
>     AutomationStatus, Connection, ConnectionType, CreateAutomationOptions, DelayStepConfig, Step,
>     TriggerStepConfig,
>   },
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let opts = CreateAutomationOptions {
>     name: "Welcome Series".to_owned(),
>     steps: vec![
>       Step::Trigger {
>         key: "start".to_owned(),
>         config: TriggerStepConfig {
>           event_name: "user.created".to_owned(),
>         },
>       },
>       Step::Delay {
>         key: "wait_1_day".to_owned(),
>         config: DelayStepConfig {
>           duration: "1 day".to_owned(),
>         },
>       },
>     ],
>     connections: vec![Connection::new("start", "wait_1_day").with_type(ConnectionType::Default)],
>     status: AutomationStatus::Disabled,
>   };
>   let _automation = resend.automations.create(opts).await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {20-24} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.AutomationConnection;
> import com.resend.services.automations.model.AutomationStep;
> import com.resend.services.automations.model.ConnectionType;
> import com.resend.services.automations.model.CreateAutomationOptions;
> import com.resend.services.automations.model.CreateAutomationResponseSuccess;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         CreateAutomationOptions options = CreateAutomationOptions.builder()
>                 .name("Welcome Series")
>                 .steps(
>                     AutomationStep.trigger("start")
>                         .eventName("user.created")
>                         .build(),
>                     AutomationStep.delay("wait_1_day")
>                         .duration("1 day")
>                         .build()
>                 )
>                 .connections(
>                     AutomationConnection.builder()
>                         .from("start")
>                         .to("wait_1_day")
>                         .type(ConnectionType.DEFAULT)
>                         .build()
>                 )
>                 .build();
>
>         CreateAutomationResponseSuccess data = resend.automations().create(options);
>     }
> }
> ```
>
> ```csharp .NET {7,15} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.created" } );
> var delayConfig = JsonSerializer.SerializeToElement( new { duration = "1 day" } );
>
> var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
> {
>     Name = "Welcome Series",
>     Steps = new List<AutomationStepData>
>     {
>         new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
>         new AutomationStepData { Ref = "wait_1_day", Type = "delay", Config = delayConfig },
>     },
>     Connections = new List<AutomationEdge>
>     {
>         new AutomationEdge { From = "start", To = "wait_1_day", EdgeType = "default" },
>     },
> } );
> ```
>
> ```bash cURL {10-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/automations' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "name": "Welcome Series",
>   "steps": [{
>     "key": "start",
>     "type": "trigger",
>     "config": { "event_name": "user.created" }
>   }, {
>     "key": "wait_1_day",
>     "type": "delay",
>     "config": { "duration": "1 day" }
>   }],
>   "connections": [
>     { "from": "start", "to": "wait_1_day", "type": "default" }
>   ]
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations create --name "Welcome Series" --file ./automation.json
> ```
>
> Example durations: `"30 minutes"`, `"1 hour"`, `"12 hours"`, `"1 day"`, `"3 days"`, `"1 week"`.

> [!NOTE]
>
> The maximum delay is 30 days.

## Configuration

**config.duration** `string` *required*

The delay duration in natural language (e.g. `"1 hour"`, `"3 days"`). Maximum:
30 days.

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "wait_1_hour",
  "type": "delay",
  "config": {
    "duration": "1 hour"
  }
}
```


# Automations
Source: https://resend.com/docs/dashboard/automations/introduction

An introduction to automating emails with custom events.

## Automations

Automations allow you to create a series of executable [steps](/docs/dashboard/automations/steps) based on [custom trigger events](/docs/dashboard/automations/trigger) from your application.

You can use Automations for repeatable actions such as:

* Welcome emails
* Drip campaigns
* Payment recovery
* Abandoned cart
* Trial expiration

## Automation features

Automations allow you to build lifecycle messages and drip campaigns with triggers, personalization, and real-time observability. You can:

* [Create automations](/docs/dashboard/automations/create-automation) to send emails or manage contacts in the Dashboard, or via Resend's code tools.
* Define your own [custom events](/docs/dashboard/automations/custom-events) to trigger automations.
* Personalize each step with options to [wait for an event](/docs/dashboard/automations/wait-for-event) or [delay the automation](/docs/dashboard/automations/delay) for a certain period of time before moving on.
* Create branched workflows by executing different steps based on whether or not [conditions](/docs/dashboard/automations/condition) are met.
* Send personalized emails from [Templates using variables](/docs/dashboard/templates/template-variables).
* Include [`{{{RESEND_UNSUBSCRIBE_URL}}}`](/docs/dashboard/broadcasts/editor#broadcast-unsubscribe-link) for compliance with non-transactional product and marketing messaging.
* Monitor and debug your [Automation execution runs](/docs/dashboard/automations/runs).

## Quickstart

Get started by [creating an automation](/docs/dashboard/automations/create-automation) in the **Automations** Dashboard page. Or, get started with the [Automation API](/docs/api-reference/automations/create-automation) and [SDKs](/docs/sdks), [CLI commands](/docs/cli#automations), or [MCP](/docs/mcp-server).

The Automation process involves the following steps:

**1. Create Automation**

Start a new Automation and give it a descriptive name.

**2. Add Trigger**

Define the event that will trigger the Automation.

**3. Define Steps**

Configure the steps to be executed.

**4. Send an Event**

Trigger the Automation by sending an event from your application.

**5. Monitor Runs**

Track and debug your Automation executions using runs.

See step-by-step examples of [creating an automation](/docs/dashboard/automations/create-automation) through the Dashboard and using the API.

## Choose your infrastructure

You can build automations, define events, and inspect automation runs entirely from the Resend Dashboard. This allows all members of your team to create and manage every aspect of your automated email flows.

To create and manage Automations from your application, you can use a variety of tools:

* [SDK](/docs/sdks): automate with an SDK built for your language
* [Integrations](/docs/integrations): automate with a framework or tool you already use
* [API](/docs/api-reference/automations/create-automation): automate with raw cURL calls
* [CLI](/docs/cli#automations): automate from the terminal
* [MCP](/docs/mcp-server): automate through your agent using natural language

See more about creating and managing automated workflows in the [related automation guides](#related-guides).

## Manage your Automations

You can view and manage your Automations from the [Automations Dashboard page](https://resend.com/automations).

The [Automations API](/docs/api-reference/automations/create-automation) and [SDKs](/docs/sdks) offer endpoints for programmatically creating, updating, retrieving, stopping, and deleting your automated workflows.

Many of these actions can also be performed with [Resend CLI commands](/docs/cli#automations) and [MCP](/docs/mcp-server).

## Track performance

You can monitor and debug the execution of your Automations from the [Automations Dashboard page](https://resend.com/automotions). You can track the status of each individual step in your workflow via an [automation run](/docs/dashboard/automations/runs) that is created every time your automation is triggered.

You can also retrieve and monitor runs with the [Automation API](/docs/api-reference/automations/list-automation-runs), an [automations CLI command](/docs/cli#automations), or [AI building tools](/docs/ai-onboarding).

## Related Guides

See how to use Resend's automation features.

> [card] [Create automations](/docs/dashboard/automations/create-automation)

> [card] [Custom triggers](/docs/dashboard/automations/custom-events)

> [card] [Steps reference](/docs/dashboard/automations/steps)

> [card] [Monitor execution runs](/docs/dashboard/automations/runs)


# Runs
Source: https://resend.com/docs/dashboard/automations/runs

Monitor and debug your Automation executions.

Every time an event [triggers](/docs/dashboard/automations/trigger) an Automation, Resend creates a run.

A run tracks the execution of each step in the workflow, including its status and timing, along with any errors.

## How it works

Each run has one of the following statuses:

| Status | Description |
| - | - |
| `running` | The Automation is executing steps |
| `completed` | All steps finished successfully |
| `failed` | A step encountered an error and the run stopped |
| `cancelled` | The run was cancelled before completing |
| `skipped` | A step was skipped because the contact has either unsubscribed or followed a different branch path |

### Skipped steps

When a contact unsubscribes, any remaining **Send Email** steps in the Automation will be skipped automatically. Other step types (such as Delay, Condition, or Update Contact) will still be executed as normal.

## Listing runs

> [tab] Using the dashboard
>
> Navigate to the [Automations page](https://resend.com/automations) and select an Automation to view its runs.
>
> ![Automation Runs](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-runs.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=b15322c27ffd309ee310250f6fc6dedd)
>
> Each run shows:
>
> * **Status** — Whether the run is `running`, `completed`, `failed`, `cancelled`, or `skipped`.
> * **Started** — When the run began.
> * **Duration** — When the run finished (if applicable).

> [tab] Using the API
>
> List all runs for an Automation:
>
> ```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.runs.list({
>   automationId: 'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
> });
> ```
>
> ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->runs->list('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd');
> ```
>
> ```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> resend.Automations.Runs.list("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
> ```
>
> ```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> Resend::Automations::Runs.list("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
> ```
>
> ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	client.Automations.ListRuns("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
> }
> ```
>
> ```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{list_opts::ListOptions, Resend, Result};
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let _runs = resend
>     .automations
>     .list_runs(
>       "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>       None,
>       ListOptions::default(),
>     )
>     .await?;
>
>   Ok(())
> }
> ```
>
> ```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.ListAutomationRunsResponseSuccess;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         ListAutomationRunsResponseSuccess data = resend.automations().listRuns("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd");
>     }
> }
> ```
>
> ```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var resp = await resend.AutomationRunListAsync( new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ) );
> Console.WriteLine( "Count={0}", resp.Content.Data.Count );
> ```
>
> ```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X GET 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/runs' \
>      -H 'Authorization: Bearer re_xxxxxxxxx'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations runs list c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd
> ```
>
> Response:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "object": "list",
>   "has_more": false,
>   "data": [
>     {
>       "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
>       "status": "completed",
>       "started_at": "2026-10-01 12:00:00.000000+00",
>       "completed_at": "2026-10-01 12:05:00.000000+00",
>       "created_at": "2026-10-01 12:00:00.000000+00"
>     }
>   ]
> }
> ```

View the [List Automation Runs API reference](/docs/api-reference/automations/list-automation-runs) for more details.

## Filtering runs by status

> [tab] Using the dashboard
>
> You can filter runs by status to find specific executions.
>
> ![Automation Runs Filter](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-runs-filter.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=9e9cb92b783ce0dbcb8569004fb9e9ef)

> [tab] Using the API
>
> You can filter by multiple statuses using a comma-separated list.
>
> ```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.runs.list({
>   automationId: 'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
>   status: ['running', 'completed'],
> });
> ```
>
> ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->runs->list('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd', [
>   'status' => 'running,completed',
> ]);
> ```
>
> ```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> resend.Automations.Runs.list(
>   "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>   params={"status": "running,completed"},
> )
> ```
>
> ```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> Resend::Automations::Runs.list(
>   "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>   status: "running,completed",
> )
> ```
>
> ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import (
> 	"context"
>
> 	"github.com/resend/resend-go/v4"
> )
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	client.Automations.ListRunsWithContext(
> 		context.TODO(),
> 		"c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
> 		&resend.ListAutomationRunsOptions{
> 			Status: []resend.AutomationRunStatus{
> 				resend.AutomationRunStatusRunning,
> 				resend.AutomationRunStatusCompleted,
> 			},
> 		},
> 	)
> }
> ```
>
> ```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{list_opts::ListOptions, Resend, Result};
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let _runs = resend
>     .automations
>     .list_runs(
>       "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>       Some("running,completed".to_owned()),
>       ListOptions::default(),
>     )
>     .await?;
>
>   Ok(())
> }
> ```
>
> ```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.ListAutomationRunsParams;
> import com.resend.services.automations.model.ListAutomationRunsResponseSuccess;
> import com.resend.services.automations.model.RunStatus;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         ListAutomationRunsParams params = ListAutomationRunsParams.builder()
>                 .status(RunStatus.RUNNING, RunStatus.COMPLETED)
>                 .build();
>         ListAutomationRunsResponseSuccess data = resend.automations().listRuns("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd", params);
>     }
> }
> ```
>
> ```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI
>
> var resp = await resend.AutomationRunListAsync(
>     new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ),
>     new AutomationRunListQuery() { Status = "running,completed" }
> );
> ```
>
> ```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X GET 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/runs?status=running,completed' \
>      -H 'Authorization: Bearer re_xxxxxxxxx'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations runs list c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd
> ```

## Viewing a single run

> [tab] Using the dashboard
>
> Click on a run to view its details, and select the step you want to debug.
>
> ![Automation Run View](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-run-view.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=57ab5b2a94a3f0a932482bb1635ae4ab)

> [tab] Using the API
>
> Get the details of a specific run:
>
> ```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.runs.get({
>   automationId: 'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
>   runId: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
> });
> ```
>
> ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->runs->get(
>   'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
>   'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
> );
> ```
>
> ```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> resend.Automations.Runs.get(
>   "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>   "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
> )
> ```
>
> ```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> Resend::Automations::Runs.get(
>   "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>   "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
> )
> ```
>
> ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	client.Automations.GetRun(
> 		"c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
> 		"a1b2c3d4-e5f6-7890-abcd-ef1234567890",
> 	)
> }
> ```
>
> ```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{Resend, Result};
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let _run = resend
>     .automations
>     .get_run(
>       "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>       "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
>     )
>     .await?;
>
>   Ok(())
> }
> ```
>
> ```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.services.automations.model.AutomationRun;
> import com.resend.services.automations.model.GetAutomationRunOptions;
>
> Resend resend = new Resend("re_xxxxxxxxx");
>
> AutomationRun data = resend.automations().getRun(
>         GetAutomationRunOptions.builder()
>                 .automationId("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
>                 .runId("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
>                 .build()
> );
> ```
>
> ```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI
>
> var resp = await resend.AutomationRunRetrieveAsync(
>     new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ),
>     new Guid( "a1b2c3d4-e5f6-7890-abcd-ef1234567890" )
> );
> Console.WriteLine( "Status={0}", resp.Content.Status );
> ```
>
> ```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X GET 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/runs/a1b2c3d4-e5f6-7890-abcd-ef1234567890' \
>      -H 'Authorization: Bearer re_xxxxxxxxx'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations runs get --automation-id c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd --run-id a1b2c3d4-e5f6-7890-abcd-ef1234567890
> ```
>
> Response:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "object": "automation_run",
>   "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
>   "status": "completed",
>   "started_at": "2026-10-01 12:00:00.000000+00",
>   "completed_at": "2026-10-01 12:05:00.000000+00",
>   "created_at": "2026-10-01 12:00:00.000000+00",
>   "steps": [
>     {
>       "key": "start",
>       "type": "trigger",
>       "status": "completed",
>       "started_at": "2026-10-01 12:00:00.000000+00",
>       "completed_at": "2026-10-01 12:00:01.000000+00",
>       "output": null,
>       "error": null
>     },
>     {
>       "key": "welcome",
>       "type": "send_email",
>       "status": "completed",
>       "started_at": "2026-10-01 12:00:01.000000+00",
>       "completed_at": "2026-10-01 12:00:02.000000+00",
>       "output": {
>         "to": "user@example.com",
>         "email_id": "6278820d-2421-42d0-85f0-80e9e28c1c69",
>         "template": {
>           "id": "caa9851e-e7bf-4a50-a408-56024edc19c0",
>           "variables": null
>         }
>       },
>       "error": null
>     }
>   ]
> }
> ```
>
> Each step in the response includes:
>
> | Field | Description |
> | - | - |
> | `key` | The unique key of the step in the automation graph |
> | `type` | The step type (e.g., `trigger`, `send_email`, `delay`) |
> | `status` | The step's execution status |
> | `started_at` | When the step started executing |
> | `completed_at` | When the step finished |
> | `output` | Output data from the step (if any) |
> | `error` | Error details if the step failed |

View the [Retrieve Automation Run API reference](/docs/api-reference/automations/get-automation-run) for more details.

## Debugging failed runs

> [tab] Using the dashboard
>
> Go to the **Runs** tab and click on a run to view the details.
>
> ![Automation Run Failed](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-run-failed.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=adf5c604c5000f28f85a65b7f2bcf82e)

> [tab] Using the API
>
> Get the details of a specific failed run:
>
> ```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.runs.get({
>   automationId: 'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
>   runId: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
> });
> ```
>
> ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->runs->get(
>   'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
>   'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
> );
> ```
>
> ```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> resend.Automations.Runs.get(
>   "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>   "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
> )
> ```
>
> ```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> Resend::Automations::Runs.get(
>   "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>   "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
> )
> ```
>
> ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	client.Automations.GetRun(
> 		"c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
> 		"a1b2c3d4-e5f6-7890-abcd-ef1234567890",
> 	)
> }
> ```
>
> ```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{Resend, Result};
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let _run = resend
>     .automations
>     .get_run(
>       "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd",
>       "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
>     )
>     .await?;
>
>   Ok(())
> }
> ```
>
> ```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.services.automations.model.AutomationRun;
> import com.resend.services.automations.model.GetAutomationRunOptions;
>
> Resend resend = new Resend("re_xxxxxxxxx");
>
> AutomationRun data = resend.automations().getRun(
>         GetAutomationRunOptions.builder()
>                 .automationId("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
>                 .runId("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
>                 .build()
> );
> ```
>
> ```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI
>
> var resp = await resend.AutomationRunRetrieveAsync(
>     new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ),
>     new Guid( "a1b2c3d4-e5f6-7890-abcd-ef1234567890" )
> );
> Console.WriteLine( "Status={0}", resp.Content.Status );
> ```
>
> ```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X GET 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/runs/a1b2c3d4-e5f6-7890-abcd-ef1234567890' \
>      -H 'Authorization: Bearer re_xxxxxxxxx'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations runs get --automation-id c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd --run-id a1b2c3d4-e5f6-7890-abcd-ef1234567890
> ```

When a run fails, use the step-level details to identify the issue:

1. **List failed runs:** Filter runs by `status=failed` to find problematic executions.
2. **Retrieve the run:** Get the full run details including the `steps` array.
3. **Find the failed step:** Look for the step with a `failed` status.
4. **Check the error:** The `error` field on the failed step contains details about what went wrong.

Common failure scenarios:

* **Condition error:** A referenced field may not exist in the event payload. See [Condition](/docs/dashboard/automations/condition) for how conditions are evaluated.
* **Wait for event timeout:** The expected event was not received within the timeout window.
* **Send email failed:** The template may not be published, or the sender address may not be verified.

## Stopping an Automation

> [tab] Using the dashboard
>
> Click on the **Stop** button to stop an Automation.
>
> ![Automation Run Stop](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-run-stop.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=8b4eb6acb320dc5960c037d327cd5fb8)

> [tab] Using the API
>
> Stop an Automation programmatically:
>
> ```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.stop(
>   'c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd',
> );
> ```
>
> ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->stop('c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd');
> ```
>
> ```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> resend.Automations.stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
> ```
>
> ```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> Resend::Automations.stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
> ```
>
> ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	client.Automations.Stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
> }
> ```
>
> ```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{Resend, Result};
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let _automation = resend
>     .automations
>     .stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd")
>     .await?;
>
>   Ok(())
> }
> ```
>
> ```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.services.automations.model.StopAutomationResponseSuccess;
>
> Resend resend = new Resend("re_xxxxxxxxx");
>
> StopAutomationResponseSuccess data = resend.automations().stop("c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd");
> ```
>
> ```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI
>
> var resp = await resend.AutomationStopAsync( new Guid( "c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd" ) );
> Console.WriteLine( "Status={0}", resp.Content.Status );
> ```
>
> ```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/automations/c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd/stop' \
>      -H 'Authorization: Bearer re_xxxxxxxxx'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations stop c9b16d4f-ba6c-4e2e-b044-6bf4404e57fd
> ```
>
> > [!NOTE]
> >
> > Stopping an Automation prevents new runs from being created.
> >
> > Existing in-progress runs will continue to completion.

View the [Stop Automation API reference](/docs/api-reference/automations/stop-automation) for more details.

## Viewing Metrics

In the dashboard, you can view overall metrics for any Automation. In the **Observability** panel for any Automation, select **Metrics**.

![Automation Runs Metrics](https://mintcdn.com/resend/HwMhsRC0UaHCUVdg/images/automations-runs-metrics.png?fit=max\&auto=format\&n=HwMhsRC0UaHCUVdg\&q=85\&s=c94ad9540f4cc11e09a67258b26745cf)

The API does not support fetching metrics for an Automation.


# Send Email
Source: https://resend.com/docs/dashboard/automations/send-email

Trigger templated emails in your Automations.

This automation step triggers a [Template](/docs/dashboard/templates/introduction) email to be sent to the contact.

## How it works

> [tab] Using the dashboard
>
> After adding a [trigger](/docs/dashboard/automations/trigger), create a new step to **Send an email**.
>
> ![Add Send Email Action](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-steps-email.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=98e94d53506699d565747e510702ad53)
>
> Select a published template, then configure the sender address.
>
> ![Send Email Action Sender Settings](https://mintcdn.com/resend/3_DkZ6MFMzztlC_E/images/automations-steps-email-settings.png?fit=max\&auto=format\&n=3_DkZ6MFMzztlC_E\&q=85\&s=312f80d13ca502ae8de7e7bffd31e251)
>
> *The subject always comes from the Template. To send a different subject, set `subject` when creating the step via the [API](#configuration).*

> [tab] Using the API
>
> Add a `send_email` step to your Automation's `steps` array.
>
> ```ts Node.js {13-21} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.create({
>   name: 'Welcome series',
>   steps: [
>     {
>       key: 'start',
>       type: 'trigger',
>       config: { eventName: 'user.created' },
>     },
>     {
>       key: 'welcome',
>       type: 'send_email',
>       config: {
>         template: {
>           id: '044db673-fff6-420f-a566-f6aba05d60e7',
>         },
>       },
>     },
>   ],
>   connections: [{ from: 'start', to: 'welcome' }],
> });
> ```
>
> ```php PHP {11-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->create([
>   'name' => 'Welcome series',
>   'steps' => [
>     [
>       'key' => 'start',
>       'type' => 'trigger',
>       'config' => ['event_name' => 'user.created'],
>     ],
>     [
>       'key' => 'welcome',
>       'type' => 'send_email',
>       'config' => [
>         'template' => [
>           'id' => '044db673-fff6-420f-a566-f6aba05d60e7',
>         ],
>       ],
>     ],
>   ],
>   'connections' => [['from' => 'start', 'to' => 'welcome']],
> ]);
> ```
>
> ```python Python {13-21} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Automations.CreateParams = {
>   "name": "Welcome series",
>   "steps": [
>     {
>       "key": "start",
>       "type": "trigger",
>       "config": {"event_name": "user.created"},
>     },
>     {
>       "key": "welcome",
>       "type": "send_email",
>       "config": {
>         "template": {
>           "id": "044db673-fff6-420f-a566-f6aba05d60e7",
>         },
>       },
>     },
>   ],
>   "connections": [{"from": "start", "to": "welcome"}],
> }
>
> resend.Automations.create(params)
> ```
>
> ```ruby Ruby {13-21} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   name: "Welcome series",
>   steps: [
>     {
>       key: "start",
>       type: "trigger",
>       config: { event_name: "user.created" },
>     },
>     {
>       key: "welcome",
>       type: "send_email",
>       config: {
>         template: {
>           id: "044db673-fff6-420f-a566-f6aba05d60e7",
>         },
>       },
>     },
>   ],
>   connections: [{ from: "start", to: "welcome" }],
> }
>
> Resend::Automations.create(params)
> ```
>
> ```go Go {18-26} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	params := &resend.CreateAutomationRequest{
> 		Name: "Welcome series",
> 		Steps: []resend.AutomationStep{
> 			{
> 				Key:  "start",
> 				Type: resend.AutomationStepTypeTrigger,
> 				Config: map[string]any{
> 					"event_name": "user.created",
> 				},
> 			},
> 			{
> 				Key:  "welcome",
> 				Type: resend.AutomationStepTypeSendEmail,
> 				Config: map[string]any{
> 					"template": map[string]any{
> 						"id": "044db673-fff6-420f-a566-f6aba05d60e7",
> 					},
> 				},
> 			},
> 		},
> 		Connections: []resend.AutomationConnection{
> 			{From: "start", To: "welcome"},
> 		},
> 	}
>
> 	client.Automations.Create(params)
> }
> ```
>
> ```rust Rust {22-27} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   types::{
>     AutomationStatus, AutomationTemplate, Connection, CreateAutomationOptions, SendEmailStepConfig,
>     Step, TriggerStepConfig,
>   },
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let opts = CreateAutomationOptions {
>     name: "Welcome series".to_owned(),
>     steps: vec![
>       Step::Trigger {
>         key: "start".to_owned(),
>         config: TriggerStepConfig {
>           event_name: "user.created".to_owned(),
>         },
>       },
>       Step::SendEmail {
>         key: "welcome".to_owned(),
>         config: SendEmailStepConfig::new(AutomationTemplate::new(
>           "044db673-fff6-420f-a566-f6aba05d60e7",
>         )),
>       },
>     ],
>     connections: vec![Connection::new("start", "welcome")],
>     status: AutomationStatus::Disabled,
>   };
>   let _automation = resend.automations.create(opts).await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {21-29} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.AutomationConnection;
> import com.resend.services.automations.model.AutomationStep;
> import com.resend.services.automations.model.CreateAutomationOptions;
> import com.resend.services.automations.model.CreateAutomationResponseSuccess;
> import java.util.Map;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         CreateAutomationOptions options = CreateAutomationOptions.builder()
>                 .name("Welcome series")
>                 .steps(
>                     AutomationStep.trigger("start")
>                         .eventName("user.created")
>                         .build(),
>                     AutomationStep.sendEmail("welcome")
>                         .template("044db673-fff6-420f-a566-f6aba05d60e7")
>                         .templateVariable("name", Map.of("var", "event.firstName"))
>                         .build()
>                 )
>                 .connections(
>                     AutomationConnection.builder()
>                         .from("start")
>                         .to("welcome")
>                         .build()
>                 )
>                 .build();
>
>         CreateAutomationResponseSuccess data = resend.automations().create(options);
>     }
> }
> ```
>
> ```csharp .NET {7-14,22} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.created" } );
> var welcomeConfig = JsonSerializer.SerializeToElement( new
> {
>     template = new
>     {
>         id = "044db673-fff6-420f-a566-f6aba05d60e7",
>         variables = new { name = new { @var = "event.firstName" } },
>     },
>     subject = "Welcome to Acme!",
>     from = "Acme <hello@example.com>",
>     reply_to = "support@example.com",
> } );
>
> var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
> {
>     Name = "Welcome series",
>     Steps = new List<AutomationStepData>
>     {
>         new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
>         new AutomationStepData { Ref = "welcome", Type = "send_email", Config = welcomeConfig },
>     },
>     Connections = new List<AutomationEdge>
>     {
>         new AutomationEdge { From = "start", To = "welcome", EdgeType = "default" },
>     },
> } );
> ```
>
> ```bash cURL {10-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/automations' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "name": "Welcome series",
>   "steps": [{
>     "key": "start",
>     "type": "trigger",
>     "config": { "event_name": "user.created" }
>   }, {
>     "key": "welcome",
>     "type": "send_email",
>     "config": {
>       "template": {
>         "id": "044db673-fff6-420f-a566-f6aba05d60e7"
>       }
>     }
>   }],
>   "connections": [
>     { "from": "start", "to": "welcome" }
>   ]
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations create --name "Welcome series" --file ./automation.json
> ```

> [!NOTE]
>
> Only `published` templates are available to be used in an Automation.

## Template variables

Use the `variables` field to pass data into your template. Each value is a static string, passed as-is, or a reference with `{ "var": "<path>" }`:

* `event.*` is a field from the event that triggered the Automation, such as `event.firstName`.
* `contact.*` is a field from the contact, such as `contact.properties.company`.
* `wait_events.<event_name>.*` is a field from an event a previous [wait for event](/docs/dashboard/automations/wait-for-event#use-the-received-event-in-later-steps) step received, such as `wait_events.feedback.received.response`. If the Automation waited for that event more than once, this is the most recent one before this step.

```json {7-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "welcome",
  "type": "send_email",
  "config": {
    "template": {
      "id": "044db673-fff6-420f-a566-f6aba05d60e7",
      "variables": {
        "firstName": { "var": "event.firstName" },
        "orderNumber": { "var": "event.orderId" },
        "total": { "var": "event.amount" },
        "company": { "var": "contact.properties.company" },
        "feedback": { "var": "wait_events.feedback.received.response" },
        "supportEmail": "help@example.com"
      }
    }
  }
}
```

Template variables must be present in your referenced template and the key names must match exactly with the template variable names.

For more help working with variables, see the [Template documentation](/docs/dashboard/templates/template-variables).

## Unsubscribe behavior

Resend does not automatically add an unsubscribe link to emails sent from a `send_email` step. To let contacts opt out, add `{{{RESEND_UNSUBSCRIBE_URL}}}` to the [Template](/docs/dashboard/templates/introduction) used by the step.

> [!NOTE]
>
> `{{{RESEND_UNSUBSCRIBE_URL}}}` must be added to the Template itself, not the step's `config`. If the Template doesn't include this variable, contacts have no way to unsubscribe from within the email.

See [when to use an unsubscribe link](/docs/knowledge-base/should-i-add-an-unsubscribe-link) to decide whether your Automation emails need one.

## Configuration

**config.template** `object` *required*

The published template to send. Provide `id` and optionally `variables`.

**properties**

**config.template.id** `string` *required*

The ID or alias of the template to send.

**config.template.variables** `object`

A key-value map of template variables. Each value can be a static string or a variable reference object (`{ "var": "event.fieldName" }`) that resolves dynamically from the `event.*`, `contact.*`, or `wait_events.*` namespaces.

**config.from** `string`

The sender email address.

If provided, this value will override the template's default value.

**config.subject** `string`

The email subject line.

If provided, this value will override the template's default value.

**config.reply\_to** `string`

Reply-to email address.

If provided, this value will override the template's default value.

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "welcome",
  "type": "send_email",
  "config": {
    "template": {
      "id": "062f8ef4-fbfa-44f1-b5e0-ff8e1e8ffa96",
      "variables": {
        "name": { "var": "event.firstName" }
      }
    },
    "from": "hello@example.com",
    "subject": "Welcome!",
    "reply_to": "support@example.com"
  }
}
```


# Steps
Source: https://resend.com/docs/dashboard/automations/steps

Steps and their properties in Automation workflows.

## Available steps

Steps are the building blocks of Automation workflows. They define the actions that will be executed when the Automation runs.

Learn more about each available step in its dedicated guide:

* [Trigger](/docs/dashboard/automations/trigger)
* [Condition](/docs/dashboard/automations/condition)
* [Delay](/docs/dashboard/automations/delay)
* [Wait for Event](/docs/dashboard/automations/wait-for-event)
* [Send Email](/docs/dashboard/automations/send-email)
* [Add to Segment](/docs/dashboard/automations/add-to-segment)
* [Contact Update](/docs/dashboard/automations/contact-update)
* [Contact Delete](/docs/dashboard/automations/contact-delete)

## Step properties

Every step in an automation has common base properties: `key`, `type`, and a `config` object whose shape depends on the type of the step.

### `key`

**key** `string` *required*

A unique identifier for the step. Used in connection definitions to connect
steps.

### `type`

**type** `string` *required*

The type of step. Possible values:

* `trigger`
* `condition`
* `delay`
* `wait_for_event`
* `send_email`
* `add_to_segment`
* `contact_update`
* `contact_delete`

### `config`

**config** `object` *required*

The configuration object for the step. The shape depends on the step `type`.

See the configuration for each step `type`:

* [`trigger`](#trigger)
* [`condition`](#condition)
* [`delay`](#delay)
* [`wait_for_event`](#wait_for_event)
* [`send_email`](#send_email)
* [`add_to_segment`](#add_to_segment)
* [`contact_update`](#contact_update)
* [`contact_delete`](#contact_delete)

## Step configuration

Below is a list of all the possible step types and their configurations.

### `trigger`

The trigger step starts the automation when a matching event is received.

**config.event\_name** `string` *required*

The name of the event that triggers the automation.

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "start",
  "type": "trigger",
  "config": {
    "event_name": "user.created"
  }
}
```

### `condition`

Branches the workflow based on rules. Condition configs can be a single rule or a logical group (`and`/`or`) of rules.

**config.type** `string` *required*

The type of condition node. Possible values:

* `rule`
* `and`
* `or`

For `rule` type:

**config.field** `string` *required*

The field to evaluate on a condition step. Use `event.` for the event that
triggered the Automation, `contact.` for the contact, or `wait_events.` for an
event received by a preceding wait for event step (for example,
`event.amount`, `contact.email`, or `wait_events.order.shipped.order_id`). A
wait for event `filter_rule` cannot use `wait_events.`.

**config.operator** `string` *required*

The comparison operator. Possible values:

* `eq`: equals
* `neq`: not equals
* `gt`: greater than
* `gte`: greater than or equal to
* `lt`: less than
* `lte`: less than or equal to
* `contains`: contains a given value
* `starts_with`: starts with a given value
* `ends_with`: ends with a given value
* `exists`: field exists
* `is_empty`: field is empty

**config.value** `string | number | boolean | null | object`

The value to compare against on a condition step. Either a fixed value or a
variable reference such as `{ "var": "event.order_id" }`, using the
condition namespaces: `event.` (the triggering event), `contact.`, or
`wait_events.` (a preceding wait for event). Not required for `exists` and
`is_empty` operators.

For `and` / `or` types:

**config.rules** `object[]` *required*

An array of nested condition config objects. Must contain at least one item.

Single rule example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "check_plan",
  "type": "condition",
  "config": {
    "type": "rule",
    "field": "event.plan",
    "operator": "eq",
    "value": "pro"
  }
}
```

Use `and` or `or` to combine multiple rules into a single branch:

```json {5-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "check_plan_and_amount",
  "type": "condition",
  "config": {
    "type": "and",
    "rules": [
      {
        "type": "rule",
        "field": "event.plan",
        "operator": "eq",
        "value": "pro"
      },
      {
        "type": "rule",
        "field": "event.amount",
        "operator": "gte",
        "value": 100
      }
    ]
  }
}
```

### `delay`

Pauses execution for a specified duration.

**config.duration** `string` *required*

The delay duration in natural language (e.g. `"1 hour"`, `"3 days"`). Maximum:
30 days.

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "wait_1_hour",
  "type": "delay",
  "config": {
    "duration": "1 hour"
  }
}
```

### `wait_for_event`

Pauses execution until a specific event is received or a timeout is reached.

**config.event\_name** `string` *required*

The name of the event to wait for.

**config.timeout** `string`

The maximum time to wait before timing out (e.g. `"3 days"`, `"1 hour"`).
Maximum: 30 days.

**config.filter\_rule** `object`

An optional rule that filters which incoming events resume the step.
`wait_events.` is not available.

**properties**

**type** `string` *required*

The type of filter rule. Possible values:

* `rule`
* `and`
* `or`

**field** `string`

Required when `type` is `rule`. The payload field to evaluate. Use
`event.` for the incoming event or `contact.` for the Automation's contact
(for example, `event.status` or `contact.email`).

**operator** `string`

Required when `type` is `rule`. The comparison operator. Possible values:

* `eq`: equals
* `neq`: not equals
* `gt`: greater than
* `gte`: greater than or equal to
* `lt`: less than
* `lte`: less than or equal to
* `contains`: contains a given value
* `starts_with`: starts with a given value
* `ends_with`: ends with a given value
* `exists`: field exists
* `is_empty`: field is empty

**value** `string | number | boolean | null | object`

Used when `type` is `rule`. The value to compare against. A fixed value,
or a variable reference such as `{ "var": "event.order_id" }`. `event.`
is the event that triggered the Automation. `contact.` is the
Automation's contact. Not required for `exists` and `is_empty`.

**rules** `object[]`

Required when `type` is `and` or `or`. An array of nested filter rules.
Must contain at least one item.

This waits for `order.paid` only when it is the order that started the Automation. `field` reads `order_id` on the incoming event. `value` reads `order_id` on the triggering event.

```json Example {9-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "wait_for_payment",
  "type": "wait_for_event",
  "config": {
    "event_name": "order.paid",
    "timeout": "3 days",
    "filter_rule": {
      "type": "rule",
      "field": "event.order_id",
      "operator": "eq",
      "value": { "var": "event.order_id" }
    }
  }
}
```

### `send_email`

Sends an email using a template.

**config.template** `object` *required*

The published template to send. Provide `id` and optionally `variables`.

**properties**

**config.template.id** `string` *required*

The ID or alias of the template to send.

**config.template.variables** `object`

A key-value map of template variables. Each value can be a static string or a variable reference object (`{ "var": "event.fieldName" }`) that resolves dynamically from the `event.*`, `contact.*`, or `wait_events.*` namespaces.

**config.from** `string`

The sender email address.

If provided, this value will override the template's default value.

**config.subject** `string`

The email subject line.

If provided, this value will override the template's default value.

**config.reply\_to** `string`

Reply-to email address.

If provided, this value will override the template's default value.

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "welcome",
  "type": "send_email",
  "config": {
    "template": {
      "id": "062f8ef4-fbfa-44f1-b5e0-ff8e1e8ffa96",
      "variables": {
        "name": { "var": "event.firstName" }
      }
    },
    "from": "hello@example.com",
    "subject": "Welcome!",
    "reply_to": "support@example.com"
  }
}
```

### `add_to_segment`

Adds the contact to a segment.

**config.segment\_id** `string` *required*

The ID of the segment to add the contact to.

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "add_to_vip",
  "type": "add_to_segment",
  "config": {
    "segment_id": "83a1e324-26dc-47eb-9b28-ba8b6d1fe808"
  }
}
```

### `contact_update`

Updates a contact's fields. Each field value can be either a hardcoded value or a dynamic variable reference using the `{ var: '...' }` syntax.

Variable references use dot-notation with one of these scopes:

* `event.*`: references a field from the triggering event payload (e.g., `event.firstName`).
* `contact.*`: references a field from the current contact (e.g., `contact.last_name`, `contact.properties.company`).

**config.first\_name** `string | object`

The contact's first name. Accepts a hardcoded string or a variable reference.

**config.last\_name** `string | object`

The contact's last name. Accepts a hardcoded string or a variable reference.

**config.unsubscribed** `boolean | object`

The contact's unsubscribed status. Accepts a boolean or a variable reference.

**config.properties** `object`

A map of custom contact properties to update. Keys correspond to your [Contact
Custom Properties](/docs/dashboard/audiences/properties). Each value can be a
hardcoded value (string, number, boolean) or a variable reference.

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "update_contact",
  "type": "contact_update",
  "config": {
    "properties": {
      "company": { "var": "event.company" },
      "vip": true
    }
  }
}
```

### `contact_delete`

Deletes the contact from the audience. This step does not require any configuration fields. Pass an empty object `{}` as the config.

```json Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "remove_contact",
  "type": "contact_delete",
  "config": {}
}
```


# Trigger
Source: https://resend.com/docs/dashboard/automations/trigger

Start your Automations based on custom events.

A trigger is the first step in every Automation. It defines which event will start the Automation when received.

When your application sends an event to Resend, every active Automation with a matching trigger will execute its workflow for that contact.

## How it works

> [tab] Using the dashboard
>
> The trigger is the first node in the editor.
>
> ![Add Trigger to Automation](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-trigger.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=1249bd18fbe832abb5b3ea0ecfe2b7ed)
>
> Choose an existing [custom event](/docs/dashboard/automations/custom-events) or type a new event name.
>
> ![Add Custom Event](https://mintcdn.com/resend/ePnINhGLisYSJsWT/images/automations-custom-event.png?fit=max\&auto=format\&n=ePnINhGLisYSJsWT\&q=85\&s=4e5b189cb756d8ca5a468746dac901a0)

> [tab] Using the API
>
> When creating an Automation via the API, the trigger is defined as the first item in the `steps` array with `type: 'trigger'`.
>
> ```ts Node.js {8-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.create({
>   name: 'Welcome series',
>   steps: [
>     {
>       key: 'start',
>       type: 'trigger',
>       config: { eventName: 'user.created' },
>     },
>   ],
>   connections: [],
> });
> ```
>
> ```php PHP {6-10} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->create([
>   'name' => 'Welcome series',
>   'steps' => [
>     [
>       'key' => 'start',
>       'type' => 'trigger',
>       'config' => ['event_name' => 'user.created'],
>     ],
>   ],
>   'connections' => [],
> ]);
> ```
>
> ```python Python {8-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Automations.CreateParams = {
>   "name": "Welcome series",
>   "steps": [
>     {
>       "key": "start",
>       "type": "trigger",
>       "config": {"event_name": "user.created"},
>     },
>   ],
>   "connections": [],
> }
>
> resend.Automations.create(params)
> ```
>
> ```ruby Ruby {8-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   name: "Welcome series",
>   steps: [
>     {
>       key: "start",
>       type: "trigger",
>       config: { event_name: "user.created" },
>     },
>   ],
>   connections: [],
> }
>
> Resend::Automations.create(params)
> ```
>
> ```go Go {11-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	params := &resend.CreateAutomationRequest{
> 		Name: "Welcome series",
> 		Steps: []resend.AutomationStep{
> 			{
> 				Key:  "start",
> 				Type: resend.AutomationStepTypeTrigger,
> 				Config: map[string]any{
> 					"event_name": "user.created",
> 				},
> 			},
> 		},
> 		Connections: []resend.AutomationConnection{},
> 	}
>
> 	client.Automations.Create(params)
> }
> ```
>
> ```rust Rust {11-16} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   types::{AutomationStatus, CreateAutomationOptions, Step, TriggerStepConfig},
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let opts = CreateAutomationOptions {
>     name: "Welcome series".to_owned(),
>     steps: vec![Step::Trigger {
>       key: "start".to_owned(),
>       config: TriggerStepConfig {
>         event_name: "user.created".to_owned(),
>       },
>     }],
>     connections: vec![],
>     status: AutomationStatus::Disabled,
>   };
>   let _automation = resend.automations.create(opts).await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {13-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.AutomationStep;
> import com.resend.services.automations.model.CreateAutomationOptions;
> import com.resend.services.automations.model.CreateAutomationResponseSuccess;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         CreateAutomationOptions options = CreateAutomationOptions.builder()
>                 .name("Welcome series")
>                 .steps(
>                     AutomationStep.trigger("start")
>                         .eventName("user.created")
>                         .build()
>                 )
>                 .build();
>
>         CreateAutomationResponseSuccess data = resend.automations().create(options);
>     }
> }
> ```
>
> ```csharp .NET {6,13} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.created" } );
>
> var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
> {
>     Name = "Welcome series",
>     Steps = new List<AutomationStepData>
>     {
>         new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
>     },
>     Connections = new List<AutomationEdge>(),
> } );
> ```
>
> ```bash cURL {6-10} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/automations' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "name": "Welcome series",
>   "steps": [{
>     "key": "start",
>     "type": "trigger",
>     "config": { "event_name": "user.created" }
>   }],
>   "connections": []
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations create --name "Welcome series" --file ./automation.json
> ```

> [!WARNING]
>
> Event names cannot start with the `resend:` prefix, which is reserved for
> system events.

## Identifying contacts

When sending an event to trigger an Automation, you must identify the contact using either a `contact_id` or an `email` address.

> [tab] Using contact ID
>
> Use a contact ID when you already have the [Contact](/docs/dashboard/contacts/introduction) stored:
>
> ```ts Node.js {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.events.send({
>   event: 'user.created',
>   contactId: '26e2b838-bf6d-4515-b6a7-17525b12b05a',
>   payload: {
>     plan: 'pro',
>   },
> });
> ```
>
> ```php PHP {5} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->events->send([
>   'event' => 'user.created',
>   'contact_id' => '26e2b838-bf6d-4515-b6a7-17525b12b05a',
>   'payload' => ['plan' => 'pro'],
> ]);
> ```
>
> ```python Python {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Events.SendParams = {
>   "event": "user.created",
>   "contact_id": "26e2b838-bf6d-4515-b6a7-17525b12b05a",
>   "payload": {"plan": "pro"},
> }
>
> resend.Events.send(params)
> ```
>
> ```ruby Ruby {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   event: "user.created",
>   contact_id: "26e2b838-bf6d-4515-b6a7-17525b12b05a",
>   payload: { plan: "pro" },
> }
>
> Resend::Events.send(params)
> ```
>
> ```go Go {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	client.Events.Send(&resend.SendEventRequest{
> 		Event:     "user.created",
> 		ContactId: "26e2b838-bf6d-4515-b6a7-17525b12b05a",
> 		Payload: map[string]any{
> 			"plan": "pro",
> 		},
> 	})
> }
> ```
>
> ```rust Rust {15-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   json,
>   types::{ContactIdOrEmail, SendEventOptions},
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let _event = resend
>     .events
>     .send(SendEventOptions {
>       event: "user.created".to_owned(),
>       contact_id_or_email: ContactIdOrEmail::ContactId(
>         "26e2b838-bf6d-4515-b6a7-17525b12b05a".to_owned(),
>       ),
>       payload: json!({ "plan": "pro" }),
>     })
>     .await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.events.model.*;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         SendEventOptions params = SendEventOptions.builder()
>                 .event("user.created")
>                 .contactId("26e2b838-bf6d-4515-b6a7-17525b12b05a")
>                 .addPayload("plan", "pro")
>                 .build();
>
>         SendEventResponseSuccess data = resend.events().send(params);
>     }
> }
> ```
>
> ```csharp .NET {11} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var payload = JsonSerializer.SerializeToElement( new { plan = "pro" } );
>
> var resp = await resend.EventSendAsync( new EventSendData()
> {
>     Event = "user.created",
>     ContactId = new Guid( "26e2b838-bf6d-4515-b6a7-17525b12b05a" ),
>     Payload = payload,
> } );
> ```
>
> ```bash cURL {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/events/send' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "event": "user.created",
>   "contact_id": "26e2b838-bf6d-4515-b6a7-17525b12b05a",
>   "payload": {
>     "plan": "pro"
>   }
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend events send \
>   --event user.created \
>   --contact-id 26e2b838-bf6d-4515-b6a7-17525b12b05a \
>   --payload '{"plan":"pro"}'
> ```

> [tab] Using email address
>
> Use an email address to trigger the Automation. If no contact with the provided email exists in your Audience, Resend will automatically create one when the run starts.
>
> ```ts Node.js {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.events.send({
>   event: 'user.created',
>   email: 'user@example.com',
>   payload: {
>     plan: 'pro',
>   },
> });
> ```
>
> ```php PHP {5} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->events->send([
>   'event' => 'user.created',
>   'email' => 'user@example.com',
>   'payload' => ['plan' => 'pro'],
> ]);
> ```
>
> ```python Python {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Events.SendParams = {
>   "event": "user.created",
>   "email": "user@example.com",
>   "payload": {"plan": "pro"},
> }
>
> resend.Events.send(params)
> ```
>
> ```ruby Ruby {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   event: "user.created",
>   email: "user@example.com",
>   payload: { plan: "pro" },
> }
>
> Resend::Events.send(params)
> ```
>
> ```go Go {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	client.Events.Send(&resend.SendEventRequest{
> 		Event: "user.created",
> 		Email: "user@example.com",
> 		Payload: map[string]any{
> 			"plan": "pro",
> 		},
> 	})
> }
> ```
>
> ```rust Rust {15} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   json,
>   types::{ContactIdOrEmail, SendEventOptions},
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let _event = resend
>     .events
>     .send(SendEventOptions {
>       event: "user.created".to_owned(),
>       contact_id_or_email: ContactIdOrEmail::Email("user@example.com".to_owned()),
>       payload: json!({ "plan": "pro" }),
>     })
>     .await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.events.model.*;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         SendEventOptions params = SendEventOptions.builder()
>                 .event("user.created")
>                 .email("user@example.com")
>                 .addPayload("plan", "pro")
>                 .build();
>
>         SendEventResponseSuccess data = resend.events().send(params);
>     }
> }
> ```
>
> ```csharp .NET {11} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var payload = JsonSerializer.SerializeToElement( new { plan = "pro" } );
>
> var resp = await resend.EventSendAsync( new EventSendData()
> {
>     Event = "user.created",
>     Email = "user@example.com",
>     Payload = payload,
> } );
> ```
>
> ```bash cURL {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/events/send' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "event": "user.created",
>   "email": "user@example.com",
>   "payload": {
>     "plan": "pro"
>   }
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend events send \
>   --event user.created \
>   --email user@example.com \
>   --payload '{"plan":"pro"}'
> ```

## Event payload

You can include a `payload` object with your event to pass data into the Automation. This data becomes available as variables in subsequent steps in the Automation using the `event.*` namespace.

```ts Node.js {8-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.events.send({
  event: 'payment.failed',
  contactId: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  payload: {
    amount: 49.99,
    currency: 'USD',
    retryDate: '2026-11-01',
  },
});
```

```php PHP {6-10} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->events->send([
  'event' => 'payment.failed',
  'contact_id' => 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  'payload' => [
    'amount' => 49.99,
    'currency' => 'USD',
    'retryDate' => '2026-11-01',
  ],
]);
```

```python Python {8-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Events.SendParams = {
  "event": "payment.failed",
  "contact_id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "payload": {
    "amount": 49.99,
    "currency": "USD",
    "retryDate": "2026-11-01",
  },
}

resend.Events.send(params)
```

```ruby Ruby {8-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  event: "payment.failed",
  contact_id: "e169aa45-1ecf-4183-9955-b1499d5701d3",
  payload: {
    amount: 49.99,
    currency: "USD",
    retryDate: "2026-11-01",
  },
}

Resend::Events.send(params)
```

```go Go {11-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Events.Send(&resend.SendEventRequest{
		Event:     "payment.failed",
		ContactId: "e169aa45-1ecf-4183-9955-b1499d5701d3",
		Payload: map[string]any{
			"amount":    49.99,
			"currency":  "USD",
			"retryDate": "2026-11-01",
		},
	})
}
```

```rust Rust {18-22} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  json,
  types::{ContactIdOrEmail, SendEventOptions},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _event = resend
    .events
    .send(SendEventOptions {
      event: "payment.failed".to_owned(),
      contact_id_or_email: ContactIdOrEmail::ContactId(
        "e169aa45-1ecf-4183-9955-b1499d5701d3".to_owned(),
      ),
      payload: json!({
        "amount": 49.99,
        "currency": "USD",
        "retryDate": "2026-11-01"
      }),
    })
    .await?;

  Ok(())
}
```

```java Java {11-13} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.events.model.*;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        SendEventOptions params = SendEventOptions.builder()
                .event("payment.failed")
                .contactId("e169aa45-1ecf-4183-9955-b1499d5701d3")
                .addPayload("amount", 49.99)
                .addPayload("currency", "USD")
                .addPayload("retryDate", "2026-11-01")
                .build();

        SendEventResponseSuccess data = resend.events().send(params);
    }
}
```

```csharp .NET {6-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Text.Json;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var payload = JsonSerializer.SerializeToElement( new
{
    amount = 49.99,
    currency = "USD",
    retryDate = "2026-11-01",
} );

var resp = await resend.EventSendAsync( new EventSendData()
{
    Event = "payment.failed",
    ContactId = new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
    Payload = payload,
} );
```

```bash cURL {7-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/events/send' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d '{
  "event": "payment.failed",
  "contact_id": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "payload": {
    "amount": 49.99,
    "currency": "USD",
    "retryDate": "2026-11-01"
  }
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend events send \
  --event payment.failed \
  --contact-id e169aa45-1ecf-4183-9955-b1499d5701d3 \
  --payload '{"amount":49.99,"currency":"USD","retryDate":"2026-11-01"}'
```

In this example, you can use `event.amount`, `event.currency`, and `event.retryDate` in other automation [conditions](/docs/dashboard/automations/condition) and steps, or in email templates.

View the [Send Event API reference](/docs/api-reference/events/send-event) for the full endpoint specification.

## Configuration

**config.event\_name** `string` *required*

The name of the event that triggers the automation.

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "start",
  "type": "trigger",
  "config": {
    "event_name": "user.created"
  }
}
```


# Wait for Event
Source: https://resend.com/docs/dashboard/automations/wait-for-event

Hold your Automations until a specific event is received.

A wait-until step holds the Automation until a specific event is received.

Unlike a delay, which resumes after a fixed time, this step resumes when something happens in your application.

Common use cases:

* **Payment**: Wait for a payment to succeed before sending a receipt.
* **Adoption**: Wait for a user to complete an action to unlock a feature.
* **Verification**: Wait for the user to verify their email before continuing.

## How it works

> [tab] Using the dashboard
>
> Add a **Wait for event** step and configure the event to wait for.
>
> ![Automation for Event](https://mintcdn.com/resend/xKsnaRV1IW7mxJit/images/automations-wait-until.png?fit=max\&auto=format\&n=xKsnaRV1IW7mxJit\&q=85\&s=76e77ac2bccd32127ebdb3d01baab410)

> [tab] Using the API
>
> Add a `wait_for_event` step to your Automation's `steps` array.
>
> ```ts Node.js {13-20} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.automations.create({
>   name: 'Verification Reminder',
>   steps: [
>     {
>       key: 'start',
>       type: 'trigger',
>       config: { eventName: 'user.created' },
>     },
>     {
>       key: 'verification',
>       type: 'wait_for_event',
>       config: {
>         eventName: 'email.verified',
>         timeout: '1 day',
>       },
>     },
>   ],
>   connections: [{ from: 'start', to: 'verification', type: 'default' }],
> });
> ```
>
> ```php PHP {11-18} theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->automations->create([
>   'name' => 'Verification Reminder',
>   'steps' => [
>     [
>       'key' => 'start',
>       'type' => 'trigger',
>       'config' => ['event_name' => 'user.created'],
>     ],
>     [
>       'key' => 'verification',
>       'type' => 'wait_for_event',
>       'config' => [
>         'event_name' => 'email.verified',
>         'timeout' => '24 hours',
>       ],
>     ],
>   ],
>   'connections' => [['from' => 'start', 'to' => 'verification', 'type' => 'default']],
> ]);
> ```
>
> ```python Python {13-20} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> params: resend.Automations.CreateParams = {
>   "name": "Verification Reminder",
>   "steps": [
>     {
>       "key": "start",
>       "type": "trigger",
>       "config": {"event_name": "user.created"},
>     },
>     {
>       "key": "verification",
>       "type": "wait_for_event",
>       "config": {
>         "event_name": "email.verified",
>         "timeout": "24 hours",
>       },
>     },
>   ],
>   "connections": [{"from": "start", "to": "verification", "type": "default"}],
> }
>
> resend.Automations.create(params)
> ```
>
> ```ruby Ruby {13-20} theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> params = {
>   name: "Verification Reminder",
>   steps: [
>     {
>       key: "start",
>       type: "trigger",
>       config: { event_name: "user.created" },
>     },
>     {
>       key: "verification",
>       type: "wait_for_event",
>       config: {
>         event_name: "email.verified",
>         timeout: "24 hours",
>       },
>     },
>   ],
>   connections: [{ from: "start", to: "verification", type: "default" }],
> }
>
> Resend::Automations.create(params)
> ```
>
> ```go Go {18-25} theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
> 	client := resend.NewClient("re_xxxxxxxxx")
>
> 	params := &resend.CreateAutomationRequest{
> 		Name: "Verification Reminder",
> 		Steps: []resend.AutomationStep{
> 			{
> 				Key:  "start",
> 				Type: resend.AutomationStepTypeTrigger,
> 				Config: map[string]any{
> 					"event_name": "user.created",
> 				},
> 			},
> 			{
> 				Key:  "verification",
> 				Type: resend.AutomationStepTypeWaitForEvent,
> 				Config: map[string]any{
> 					"event_name": "email.verified",
> 					"timeout":    "24 hours",
> 				},
> 			},
> 		},
> 		Connections: []resend.AutomationConnection{
> 			{From: "start", To: "verification", Type: resend.AutomationConnectionTypeDefault},
> 		},
> 	}
>
> 	client.Automations.Create(params)
> }
> ```
>
> ```rust Rust {22-29} theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{
>   types::{
>     AutomationStatus, Connection, ConnectionType, CreateAutomationOptions, Step, TriggerStepConfig,
>     WaitForEventStepConfig,
>   },
>   Resend, Result,
> };
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let opts = CreateAutomationOptions {
>     name: "Verification Reminder".to_owned(),
>     steps: vec![
>       Step::Trigger {
>         key: "start".to_owned(),
>         config: TriggerStepConfig {
>           event_name: "user.created".to_owned(),
>         },
>       },
>       Step::WaitForEvent {
>         key: "verification".to_owned(),
>         config: WaitForEventStepConfig {
>           event_name: "email.verified".to_owned(),
>           timeout: Some("24 hours".to_owned()),
>           filter_rule: None,
>         },
>       },
>     ],
>     connections: vec![Connection::new("start", "verification").with_type(ConnectionType::Default)],
>     status: AutomationStatus::Disabled,
>   };
>   let _automation = resend.automations.create(opts).await?;
>
>   Ok(())
> }
> ```
>
> ```java Java {20-25} theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
> import com.resend.services.automations.model.AutomationConnection;
> import com.resend.services.automations.model.AutomationStep;
> import com.resend.services.automations.model.ConnectionType;
> import com.resend.services.automations.model.CreateAutomationOptions;
> import com.resend.services.automations.model.CreateAutomationResponseSuccess;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         CreateAutomationOptions options = CreateAutomationOptions.builder()
>                 .name("Verification Reminder")
>                 .steps(
>                     AutomationStep.trigger("start")
>                         .eventName("user.created")
>                         .build(),
>                     AutomationStep.waitForEvent("verification")
>                         .eventName("email.verified")
>                         .timeout("1 day")
>                         .build()
>                 )
>                 .connections(
>                     AutomationConnection.builder()
>                         .from("start")
>                         .to("verification")
>                         .type(ConnectionType.DEFAULT)
>                         .build()
>                 )
>                 .build();
>
>         CreateAutomationResponseSuccess data = resend.automations().create(options);
>     }
> }
> ```
>
> ```csharp .NET {7-11,19} theme={"theme":{"light":"github-light","dark":"vesper"}}
> using Resend;
> using System.Text.Json;
>
> IResend resend = ResendClient.Create( "re_xxxxxxxxx" );
>
> var startConfig = JsonSerializer.SerializeToElement( new { event_name = "user.created" } );
> var waitConfig = JsonSerializer.SerializeToElement( new
> {
>     event_name = "email.verified",
>     timeout = "1 day",
> } );
>
> var resp = await resend.AutomationCreateAsync( new AutomationCreateData()
> {
>     Name = "Verification Reminder",
>     Steps = new List<AutomationStepData>
>     {
>         new AutomationStepData { Ref = "start", Type = "trigger", Config = startConfig },
>         new AutomationStepData { Ref = "verification", Type = "wait_for_event", Config = waitConfig },
>     },
>     Connections = new List<AutomationEdge>
>     {
>         new AutomationEdge { From = "start", To = "verification", EdgeType = "default" },
>     },
> } );
> ```
>
> ```bash cURL {10-16} theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X POST 'https://api.resend.com/automations' \
>      -H 'Authorization: Bearer re_xxxxxxxxx' \
>      -H 'Content-Type: application/json' \
>      -d '{
>   "name": "Verification Reminder",
>   "steps": [{
>     "key": "start",
>     "type": "trigger",
>     "config": { "event_name": "user.created" }
>   }, {
>     "key": "verification",
>     "type": "wait_for_event",
>     "config": {
>       "event_name": "email.verified"
>     }
>   }],
>   "connections": [
>     { "from": "start", "to": "verification", "type": "default" }
>   ]
> }'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend automations create --name "Verification Reminder" --file ./automation.json
> ```

## Timeouts

When you set a `timeout`, the step will stop waiting after that duration. This prevents Automations from waiting indefinitely.

When a wait-until step times out, it produces two possible connection types:

| Connection type | When it's used |
| - | - |
| `event_received` | The event arrived before the timeout |
| `timeout` | The timeout elapsed without receiving the event |

You can create different paths depending on whether the user took action within an given time period.

```json {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "payment",
  "type": "wait_for_event",
  "config": {
    "event_name": "payment.completed",
    "timeout": "3 days"
  }
}
```

> [!NOTE]
>
> The maximum timeout is 30 days.

## Filter rules

Use `filter_rule` to match events that meet only specific criteria. This is useful when the same event name might be sent with different payloads.

`wait_events.*` is not available.

* `field` reads the incoming event (`event.*`) or the Automation's contact (`contact.*`).
* `value` is a fixed value, or it reads the event that triggered the Automation (`event.*`) or the contact (`contact.*`).

See [Configuration](#configuration) for every operator a filter rule supports.

For example, to wait specifically for a successful payment:

```json {6-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "payment",
  "type": "wait_for_event",
  "config": {
    "event_name": "payment.completed",
    "filter_rule": {
      "type": "rule",
      "field": "event.status",
      "operator": "eq",
      "value": "succeeded"
    }
  }
}
```

### Compare against the triggering event

`field` and `value` can use the same path and still read different payloads. In a `value`, `event.*` is the event that triggered the Automation, not the incoming event.

For example, an Automation triggered by `order.placed` can wait for `order.paid` for the same order:

```json {8-10} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "wait_for_payment",
  "type": "wait_for_event",
  "config": {
    "event_name": "order.paid",
    "filter_rule": {
      "type": "rule",
      "field": "event.order_id",
      "operator": "eq",
      "value": { "var": "event.order_id" }
    }
  }
}
```

Here, `field` reads `order_id` from the incoming `order.paid` event, and `value` reads `order_id` from the `order.placed` event that started the Automation. `order.paid` events for other orders don't resume it.

A `value` can also reference the contact, such as `{ "var": "contact.email" }`. Neither `field` nor `value` can reference `wait_events.*`.

## Use the received event in later steps

When the event arrives, steps after the wait can read its payload with `wait_events`. The path is `wait_events.`, then the event name, then the payload field. In `wait_events.order.shipped.tracking_url`, the event name is `order.shipped` and the field is `tracking_url`.

For example, wait for `order.shipped`, then send its tracking link:

```json {6,15-16,23} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "steps": [
    {
      "key": "wait_for_shipping",
      "type": "wait_for_event",
      "config": { "event_name": "order.shipped", "timeout": "7 days" }
    },
    {
      "key": "shipping_email",
      "type": "send_email",
      "config": {
        "template": {
          "id": "044db673-fff6-420f-a566-f6aba05d60e7",
          "variables": {
            "carrier": { "var": "wait_events.order.shipped.carrier" },
            "trackingUrl": { "var": "wait_events.order.shipped.tracking_url" }
          }
        }
      }
    }
  ],
  "connections": [
    {
      "from": "wait_for_shipping",
      "to": "shipping_email",
      "type": "event_received"
    }
  ]
}
```

Connect the step to the `event_received` path. On the `timeout` path, the event never arrived, so there's no payload to read.

You can use `wait_events` in [send email](/docs/dashboard/automations/send-email#template-variables) variables, [contact update](/docs/dashboard/automations/contact-update#dynamic-variables) fields, and [condition](/docs/dashboard/automations/condition#compare-against-other-data) rules.

## Configuration

**config.event\_name** `string` *required*

The name of the event to wait for.

**config.timeout** `string`

The maximum time to wait before timing out (e.g. `"3 days"`, `"1 hour"`).
Maximum: 30 days.

**config.filter\_rule** `object`

An optional rule that filters which incoming events resume the step.
`wait_events.` is not available.

**properties**

**type** `string` *required*

The type of filter rule. Possible values:

* `rule`
* `and`
* `or`

**field** `string`

Required when `type` is `rule`. The payload field to evaluate. Use
`event.` for the incoming event or `contact.` for the Automation's contact
(for example, `event.status` or `contact.email`).

**operator** `string`

Required when `type` is `rule`. The comparison operator. Possible values:

* `eq`: equals
* `neq`: not equals
* `gt`: greater than
* `gte`: greater than or equal to
* `lt`: less than
* `lte`: less than or equal to
* `contains`: contains a given value
* `starts_with`: starts with a given value
* `ends_with`: ends with a given value
* `exists`: field exists
* `is_empty`: field is empty

**value** `string | number | boolean | null | object`

Used when `type` is `rule`. The value to compare against. A fixed value,
or a variable reference such as `{ "var": "event.order_id" }`. `event.`
is the event that triggered the Automation. `contact.` is the
Automation's contact. Not required for `exists` and `is_empty`.

**rules** `object[]`

Required when `type` is `and` or `or`. An array of nested filter rules.
Must contain at least one item.

This waits for `order.paid` only when it is the order that started the Automation. `field` reads `order_id` on the incoming event. `value` reads `order_id` on the triggering event.

```json Example {9-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "key": "wait_for_payment",
  "type": "wait_for_event",
  "config": {
    "event_name": "order.paid",
    "timeout": "3 days",
    "filter_rule": {
      "type": "rule",
      "field": "event.order_id",
      "operator": "eq",
      "value": { "var": "event.order_id" }
    }
  }
}
```


# Compose and send with the Broadcast editor
Source: https://resend.com/docs/dashboard/broadcasts/editor

Learn how to write and send your Broadcasts in the Dashboard editor

Resend's no-code Broadcast editor is built into the Dashboard to allow anyone on your team to create and send your bulk marketing emails.

> [!NOTE]
>
> To create a Broadcast from your application instead, you can [send Broadcasts
> with the Broadcasts API
> instead](/docs/dashboard/broadcasts/send-broadcast-with-api).

## Quickstart

To create and send a Broadcast using the no-code editor:

**1. Go to the Broadcasts page in your Resend dashboard.**

**2. Click `Create Broadcast`.**

**3. Add a `from` name and address.**

Choose any username at your [verified domain](/docs/dashboard/domains/introduction) to send your Broadcast from.

We suggest you choose a `from` name and address that describes the purpose of the email, for example:

* `My Company Name <company@updates.example.com>`
* `My Newsletter <company@newsletter.example.com>`.

**4. Select the audience you want to send your email to.**

Choose a [segment of your contacts](/docs/dashboard/segments/introduction) to receive the email.

**5. Create a subject for your email.**

**6. Optionally define other email fields.**

Resend's Broadcast editor allows you to specify optional fields such as a different Reply-to address, a [topic](/docs/dashboard/topics/introduction), preview text for email clients, and a scheduled time to send.

**7. Write your email content.**

Use `/` commands in the Broadcast editor for UI elements such as headings, lists, and images. You can also [compose your body text in Markdown](#markdown-support).

**8. Use the sidebar to add custom styles.**

When you select an element of your Broadcast, such as text, images, or the entire page, contextual styling menu options show in the page sidebar. [Choose colors, sizes, layouts, and more](#custom-styling) or add your own global CSS styles directly in the editor.

**9. Add an unsubscribe link.**

Use the [Resend unsubscribe footer](#broadcast-unsubscribe-link) to allow your contacts to indicate they no longer want to receive your marketing emails.

**10. Send yourself a test email.**

Click `Test email` and add one or more email addresses to receive your test email and preview how your Broadcast will look in your own email. If applicable, you can add test data for contact properties used in the Broadcast when sending a test email.

**11. Review your Broadcast.**

Click **Review** to prompt Resend's review feature, which checks for for any errors or concerns with your Broadcast and helps you catch common mistakes before sending.

You may be forced to address some issues before you are allowed to send your email.

**12. Slide to send.**

When there are no errors, the "Slide to send" element will activate. Slide the arrow to confirm that you are ready to send immediately, or at the configured scheduled time.

Alternatively, exit the editor to leave your Broadcast saved as a draft. It is automatically saved as you compose.

## Markdown Support

You can also write your emails using Markdown headings, lists, italic, bold, links, and quotes.

If you copy and paste content from other rich or plain text applications, the editor maintains formatting consistency.

<video />

## Custom Styling

You can customize the look and feel of your email by changing **global styles** such as the background color, link color, and container size, allowing you to create emails aligned with your brand identity.

To do this, click on **Styles** at the top left of the Broadcast editor. You can edit specific images or lines of text by selecting or highlighting them prior to clicking on **Styles**.

<video />

You can also edit individual styles for each component, including the font size, font weight, letter spacing, line height, and text alignment. You can also set custom properties for each component, such as image alt, button links, and social links.

<video />

The editor additionally includes a built-in AI editor that can style and edit
your content, or `@` mention other Broadcasts for design or content inspiration.

## Personalize your content

When creating Broadcasts, you can include dynamic audience data to personalize the email content.

Add placeholders for your [contact properties](/docs/dashboard/audiences/properties) using the following notation:

* `{{{contact.first_name|fallback}}}`
* `{{{contact.last_name|fallback}}}`
* `{{{contact.email}}}`

## Broadcast unsubscribe link

Resend generates a unique link for each recipient and each Broadcast. Use `{{{RESEND_UNSUBSCRIBE_URL}}}` as the link target in your footer to send readers to your unsubscribe page.

![Unsubscribe Link](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/audiences-intro-3.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=4b37fb9c380e19ca0b53b80a3c925c8f)

When a contact clicks this link, they will be presented with a preference page where they can update their subscription preferences [per topic](/docs/dashboard/topics/introduction) or unsubscribe from all of your emails.

![Automatic Unsubscribes](https://mintcdn.com/resend/m2xttJpF68pi6Mw0/images/audiences-intro-4.png?fit=max\&auto=format\&n=m2xttJpF68pi6Mw0\&q=85\&s=b9715a7bb5d97a3795cf82978073895e)

You can [customize your unsubscribe page with your branding](/docs/dashboard/settings/unsubscribe-page) from your team settings.

![See Topics on the Unsubscribe Page](https://mintcdn.com/resend/WTZjpSkJsZf7Ubl_/images/dashboard-unsubscribe-page-topics.png?fit=max\&auto=format\&n=WTZjpSkJsZf7Ubl_\&q=85\&s=11896d54a3e2bdb510a5b666ae7ee8a8)

## Testing & Sending

Once you're finished writing your email, preview it in your personal inbox or send it to your team for feedback.

To do this, click on **Test Email** on the top right of your screen. Enter in the email address you'd like to send your email to, and then click on **Send Test Email** to complete.

Once you're ready to send your email to your Audience, click on **Send**, and slide to confirm.

<video />

> [!NOTE]
>
> Test emails do not include any custom Reply-To address. This behavior is
> limited to test mode and does not affect actual email sends.

## Cancel a Broadcast

You can [cancel a Broadcast](/docs/knowledge-base/how-do-i-cancel-a-broadcast) while it is still sending by clicking on the Broadcast's **Cancel** button in the Dashboard. Canceling stops the send and cancels all queued deliveries, so no further emails go out.

This only stops delivery of emails that have not yet been sent. Emails that have already been delivered cannot be recalled.


# Sending Broadcasts
Source: https://resend.com/docs/dashboard/broadcasts/introduction

An introduction to sending bulk marketing emails with Resend.

## Sending marketing emails

Resend provides all the tools you need to send bulk marketing emails to your Contacts. These are useful for:

* Newsletters
* Product Launches
* Investor Updates
* Promotions
* Changelogs

Resend's Broadcast features include tools for content creation, contact management, and performance tracking while handling queuing, throttling, and scheduling for you so that you don't have to roll your own infrastructure.

> [!TIP]
>
> To send transactional emails, use the
> [Sending](/docs/dashboard/emails/introduction) feature.

## Broadcast features

With Resend's Broadcast features, you can:

* Compose, schedule, and send marketing emails using a [no-code editor](/docs/dashboard/broadcasts/editor) directly in your Dashboard.
* Organize your contacts into [segments](/docs/dashboard/segments/introduction) and send bulk emails to only targeted contacts.
* Categorize your marketing emails by [topics](/docs/dashboard/topics/introduction) to allow recipients to choose which emails to receive.
* Turn your emails into reusable [templates](/docs/dashboard/templates/introduction).
* [Track performance metrics](/docs/dashboard/broadcasts/performance-tracking) such as delivery, click, and open rates.

## Quickstart

You can send bulk marketing emails from [a verified domain](/docs/dashboard/domains/introduction) to a [segment](/docs/dashboard/segments/introduction) of your contact list.

> [!TIP]
>
> You can create a draft Broadcast and send a test email to preview your content
> even before you add any contacts. However, you will need to create a segment
> before you can send your Broadcast.

**1. Add contacts.**

[Add or import contacts](/docs/dashboard/contacts/add-contacts) manually or
programmatically. You can also upload a `.csv` file of existing contacts.

**2. Create a segment and add contacts.**

Broadcasts are sent to a [segment](/docs/dashboard/segments/introduction) of your
audience.

**3. Write and send your Broadcast.**

[Create and send a Broadcast entirely using the no-code
editor](/docs/dashboard/broadcasts/editor). Alternatively, you can [use the
Broadcast API to build and distribute your
Broadcast](/docs/dashboard/broadcasts/send-broadcast-with-api) from your
application.

**4. Check your performance.**

View the details of any sent Broadcast in the [**Broadcasts Dashboard
Page**](https://resend.com/broadcasts) to see real-time deliverability
metrics, open and click tracking (if enabled), and subscriber actions.

## Choose your infrastructure

You can build and send your Broadcasts entirely from the [Resend Dashboard](https://resend.com/broadcasts). This allows all members of your team to create and manage every aspect of your marketing emails.

To create, send, and manage Broadcasts from your application, you can also use a variety of tools:

* [SDK](/docs/sdks): send with an SDK built for your language
* [Integrations](/docs/integrations): send from a framework or tool you already use
* [API](/docs/api-reference/emails/send-email): send with raw cURL calls
* [CLI](/docs/cli#emails): send emails from the terminal
* [MCP](/docs/mcp-server): send through your agent with MCP

> [!NOTE]
>
> &#x20;
>
> You can also create [automations](/docs/dashboard/automations/introduction) for
> repeatable transactional emails like welcoming new subscribers, and Broadcast
> needs like updating your contact list.

See how to use Resend's Broadcast and contact management features in the [related guides](#related-guides).

## Manage your Broadcasts

You can view and manage your Broadcasts from the [Broadcasts Dashboard page](https://resend.com/broadcasts).

You can also [manage your Broadcasts through the Broadcast API](/docs/api-reference/broadcasts/create-broadcast) which offers endpoints for programmatically creating, updating, and sending Broadcasts. Many of these actions can also be performed with [Resend Broadcast CLI commands](/docs/cli#broadcasts) and [AI building tools](/docs/ai-onboarding). You can also create [automations](/docs/dashboard/automations/introduction) for workflows related to your Broadcasts, such as managing your contact list.

Learn more about [managing your Broadcasts](/docs/dashboard/broadcasts/manage-broadcasts) in the dedicated guide.

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

> [!NOTE]
>
> Currently, exports are limited to admin users of your team.

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

> [!NOTE]
>
> All exports your team creates are listed in the
> [Exports](https://resend.com/exports) page under **Settings** > **Team** >
> **Exports**. Select any export to view its details page. All members of your
> team can view your exports, but only admins can download the data.

## Related Guides

See how to use Resend's Broadcast features.

> [card] [No-code editor](/docs/dashboard/broadcasts/editor)

> [card] [Send with API](/docs/dashboard/broadcasts/send-broadcast-with-api)

> [card] [Manage Broadcasts](/docs/dashboard/broadcasts/manage-broadcasts)

> [card] [Contacts](/docs/dashboard/contacts/introduction)

> [card] [Segments](/docs/dashboard/segments/introduction)

> [card] [Topics](/docs/dashboard/topics/introduction)

> [card] [Track performance](/docs/dashboard/broadcasts/performance-tracking)

> [card] [Handle unsubscribes](/docs/dashboard/audiences/managing-unsubscribe-list)


# Manage Broadcasts
Source: https://resend.com/docs/dashboard/broadcasts/manage-broadcasts

Learn how to view, update, and delete your Broadcasts.

After you create your first Broadcast, all members of your team can view and manage existing Broadcast details directly in the [**Broadcasts** Dashboard page](https://resend.com/broadcasts). You can also perform bulk actions (cancel, delete) by selecting multiple Broadcasts.

To manage your marketing campaigns directly from your application, you can use the [Broadcast API](/docs/api-reference/broadcasts/create-broadcast) endpoints to list, retrieve, update, and delete your existing Broadcasts.

You can also manage your Broadcasts using [Resend CLI commands](/docs/cli#broadcasts) and [AI building tools](/docs/ai-onboarding).

## View Broadcasts

See the name, [status](#understand-broadcast-statuses), and created date of all your Broadcasts from the Emails Dashboard page. These can also be filtered by status and [audience](/docs/dashboard/segments/introduction).

Select any individual Broadcast to view its details. The view will depend on the status of the email. For example, Broadcasts that have been sent will show deliverability metrics as well as your content as a preview, plain text, and HTML.

Clicking on a draft Broadcast will bring up the Dashboard editor for further editing.

## Understand Broadcast statuses

Here are all the statuses that can be associated with a Broadcast:

* `draft`: The Broadcast is a draft. Drafts can be edited, deleted, or scheduled for sending.
* `scheduled`: The Broadcast is scheduled to be sent at a specific time. Scheduled Broadcasts can have their schedule canceled, which returns them to draft status and prevents any emails from being sent.
* `sent`: The Broadcast was sent.
* `queued`: The Broadcast is queued for delivery. Canceling a queued Broadcast stops delivery to the remaining recipients only. Emails already sent cannot be recalled.
* `canceled`: The Broadcast was canceled while it was queued for delivery. It cannot be sent again.

## Edit Broadcasts

You can edit the content and properties of any draft or scheduled Broadcast. Once a Broadcast has been sent, only its name can be updated.

To edit an existing draft or scheduled Broadcast in the Dashboard:

1. Click the name of the Broadcast you want to edit.
2. Use the Dashboard editor to update any properties or content.
3. Exit the editor when you have finished editing. Your changes will be automatically saved.

## Cancel scheduled Broadcasts

Canceling a Broadcast only stops emails that haven't been sent yet. Any emails already delivered cannot be recalled. If a Broadcast is mid-send (`queued`), canceling halts delivery to the remaining recipients.

To cancel the schedule for one or more scheduled Broadcasts in the Dashboard:

1. Select the scheduled Broadcast(s) you want to cancel.
2. Click **Cancel schedule** in the bottom action bar.
3. Type `CANCEL` to confirm.
4. Press **Cmd+Enter** or click **Cancel schedules** to complete.

When you cancel a scheduled Broadcast, it returns to draft status and won't be sent at the scheduled time. When you cancel a Broadcast that is mid-send (`queued`), it is set to the `canceled` status and cannot be sent again.

## Delete draft Broadcasts

Only draft (including scheduled) Broadcasts can be deleted. Once a Broadcast has been sent or queued, it can't be deleted.

To delete one or more draft Broadcasts in the Dashboard:

1. Select the Broadcast(s) you want to delete by clicking the checkboxes next to each Broadcast.
2. Click **Delete** in the bottom action bar.
3. Type the Broadcast name (for single selection) or `DELETE N BROADCASTS` (for multiple) to confirm.
4. Press **Cmd+Enter** or click **Delete Broadcasts** to complete.

You can also use keyboard shortcuts:

* **Cmd+A** to select all Broadcasts on the current page
* **Backspace** to open the delete confirmation modal

## API Reference

For complete API documentation, see the [Broadcasts API reference](/docs/api-reference/broadcasts/create-broadcast).


# Performance Tracking
Source: https://resend.com/docs/dashboard/broadcasts/performance-tracking

Track your Broadcasts email performance in real-time

Once your broadcast is sent, you can track its performance right away. The insights you can view are emails delivered, unsubscribed, click rate, and open rate.

You can view these insights by clicking on [Broadcast](https://resend.com/broadcasts) in the left column, and then clicking on the Broadcast that you want to view.

<video />

Please note, at times, open rates can be inaccurate for a number of reasons due to the way inbox providers handle incoming emails. You can [read more about this here.](https://resend.com/docs/knowledge-base/why-are-my-open-rates-not-accurate)


# Compose and send Broadcasts with the API
Source: https://resend.com/docs/dashboard/broadcasts/send-broadcast-with-api

Send marketing emails using the Broadcasts API.

Resend's [no-code Broadcast editor](/docs/dashboard/broadcasts/editor) allows all members of your team to write and send email campaigns directly in the Resend Dashboard, without having to ask for help from developers.

To programmatically create, update, and send Broadcasts, you can use the [Broadcast API](/docs/api-reference/broadcasts/create-broadcast). There are also API endpoints to list, retrieve, and delete Broadcasts, allowing you to manage your marketing campaigns directly from your application.

## Create Broadcasts

The [`create()` method](/docs/api-reference/broadcasts/create-broadcast) takes the same sending properties that can be set in the Editor composer. This allows developers to also create drafts without sending, schedule sending for a time in the future, [personalize with dynamic content data](/docs/dashboard/broadcasts/editor#personalize-your-content), and more.

Set the `send` property to `true` to send immediately or to schedule the Broadcast, or leave `false` (the default) to create a draft:

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

// Create a draft Broadcast
const { data, error } = await resend.broadcasts.create({
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  from: 'Acme <onboarding@resend.dev>',
  subject: 'hello world',
  html: 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
});

// Create and send immediately
const { data: sent, error: sendError } = await resend.broadcasts.create({
  segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  from: 'Acme <onboarding@resend.dev>',
  subject: 'hello world',
  html: 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
  send: true,
});

// Create and schedule
const { data: scheduled, error: scheduleError } =
  await resend.broadcasts.create({
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
    from: 'Acme <onboarding@resend.dev>',
    subject: 'hello world',
    html: 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
    send: true,
    scheduledAt: 'in 1 hour',
  });
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Create a draft Broadcast
$resend->broadcasts->create([
  'segment_id' => '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  'from' => 'Acme <onboarding@resend.dev>',
  'subject' => 'hello world',
  'html' => 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
]);

// Create and send immediately
$resend->broadcasts->create([
  'segment_id' => '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  'from' => 'Acme <onboarding@resend.dev>',
  'subject' => 'hello world',
  'html' => 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
  'send' => true,
]);

// Create and schedule
$resend->broadcasts->create([
  'segment_id' => '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  'from' => 'Acme <onboarding@resend.dev>',
  'subject' => 'hello world',
  'html' => 'Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
  'send' => true,
  'scheduled_at' => 'in 1 hour',
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Create a draft Broadcast
params: resend.Broadcasts.CreateParams = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
}
resend.Broadcasts.create(params)

# Create and send immediately
params: resend.Broadcasts.CreateParams = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": True,
}
resend.Broadcasts.create(params)

# Create and schedule
params: resend.Broadcasts.CreateParams = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": True,
  "scheduled_at": "in 1 hour",
}
resend.Broadcasts.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Create a draft Broadcast
params = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "hello world",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
}
Resend::Broadcasts.create(params)

# Create and send immediately
params = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": true,
}
Resend::Broadcasts.create(params)

# Create and schedule
params = {
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "Hello, world!",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": true,
  "scheduled_at": "in 1 hour",
}
Resend::Broadcasts.create(params)

```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	// Create a draft Broadcast
	params := &resend.CreateBroadcastRequest{
		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
		From:      "Acme <onboarding@resend.dev>",
		Html:      "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
		Subject:   "Hello, world!",
	}
	client.Broadcasts.Create(params)

	// Create and send immediately
	params = &resend.CreateBroadcastRequest{
		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
		From:      "Acme <onboarding@resend.dev>",
		Subject:   "Hello, world!",
		Html:      "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
		Send:      true,
	}
	client.Broadcasts.Create(params)

	// Create and schedule
	params = &resend.CreateBroadcastRequest{
		SegmentId:   "78261eea-8f8b-4381-83c6-79fa7120f1cf",
		From:        "Acme <onboarding@resend.dev>",
		Subject:     "Hello, world!",
		Html:        "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
		Send:        true,
		ScheduledAt: "in 1 hour",
	}
	client.Broadcasts.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateBroadcastOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let segment_id = "78261eea-8f8b-4381-83c6-79fa7120f1cf";
  let from = "Acme <onboarding@resend.dev>";
  let subject = "hello world";
  let html = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}";

  let opts = CreateBroadcastOptions::new(segment_id, from, subject).with_html(html);

  // Create a draft Broadcast
  let _broadcast = resend.broadcasts.create(opts.clone()).await?;

  // Create and send immediately
  let _broadcast = resend
    .broadcasts
    .create(opts.clone().with_send(true))
    .await?;

  // Create and schedule
  let _broadcast = resend
    .broadcasts
    .create(opts.with_send(true).with_scheduled_at("in 1 hour"))
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.services.broadcasts.model.CreateBroadcastOptions;
import com.resend.services.broadcasts.model.CreateBroadcastResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

// Create a draft broadcast
CreateBroadcastOptions params = CreateBroadcastOptions.builder()
    .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
    .from("Acme <onboarding@resend.dev>")
    .subject("hello world")
    .html("Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
    .build();
CreateBroadcastResponseSuccess data = resend.broadcasts().create(params);

// Create and send immediately
CreateBroadcastOptions sendParams = CreateBroadcastOptions.builder()
    .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
    .from("Acme <onboarding@resend.dev>")
    .subject("hello world")
    .html("Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
    .send(true)
    .build();
CreateBroadcastResponseSuccess sent = resend.broadcasts().create(sendParams);

// Create and schedule
CreateBroadcastOptions scheduleParams = CreateBroadcastOptions.builder()
    .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
    .from("Acme <onboarding@resend.dev>")
    .subject("hello world")
    .html("Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
    .send(true)
    .scheduledAt("in 1 hour")
    .build();
CreateBroadcastResponseSuccess scheduled = resend.broadcasts().create(scheduleParams);
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// Create a draft Broadcast
var resp = await resend.BroadcastAddAsync(
    new BroadcastData()
    {
        DisplayName = "Example Broadcast",
        SegmentId = new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ),
        From = "Acme <onboarding@resend.dev>",
        Subject = "Hello, world!",
        HtmlBody = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
    }
);

Console.WriteLine( "Broadcast Id={0}", resp.Content );

// Create and send immediately
var sent = await resend.BroadcastAddAsync(
    new BroadcastData()
    {
        DisplayName = "Example Broadcast",
        SegmentId = new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ),
        From = "Acme <onboarding@resend.dev>",
        Subject = "Hello, world!",
        HtmlBody = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
        SendAfterAdd = true,
    }
);

Console.WriteLine( "Broadcast Id={0}", sent.Content );

// Create and schedule
var scheduled = await resend.BroadcastAddAsync(
    new BroadcastData()
    {
        DisplayName = "Example Broadcast",
        SegmentId = new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ),
        From = "Acme <onboarding@resend.dev>",
        Subject = "Hello, world!",
        HtmlBody = "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
        SendAfterAdd = true,
        MomentSchedule = DateTime.UtcNow.AddHours( 1 ),
    }
);

Console.WriteLine( "Broadcast Id={0}", scheduled.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Create a draft Broadcast
curl -X POST 'https://api.resend.com/broadcasts' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'
{
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "hello world",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}"
}'

# Create and send immediately
curl -X POST 'https://api.resend.com/broadcasts' \
 -H 'Authorization: Bearer re_xxxxxxxxx' \
 -H 'Content-Type: application/json' \
 -d $'
{
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "hello world",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": true
}'

# Create and schedule
curl -X POST 'https://api.resend.com/broadcasts' \
 -H 'Authorization: Bearer re_xxxxxxxxx' \
 -H 'Content-Type: application/json' \
 -d $'
{
  "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  "from": "Acme <onboarding@resend.dev>",
  "subject": "hello world",
  "html": "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  "send": true,
  "scheduled_at": "in 1 hour"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Create a draft Broadcast
resend broadcasts create \
  --from "Acme <onboarding@resend.dev>" \
  --subject "hello world" \
  --segment-id 78261eea-8f8b-4381-83c6-79fa7120f1cf \
  --html "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}"

# Create and send immediately
resend broadcasts create \
  --from "Acme <onboarding@resend.dev>" \
  --subject "hello world" \
  --segment-id 78261eea-8f8b-4381-83c6-79fa7120f1cf \
  --html "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}" \
  --send

# Create and schedule
resend broadcasts create \
  --from "Acme <onboarding@resend.dev>" \
  --subject "hello world" \
  --segment-id 78261eea-8f8b-4381-83c6-79fa7120f1cf \
  --html "Hi {{{contact.first_name|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}" \
  --send \
  --scheduled-at "in 1 hour"
```

## Send Broadcasts

Use the [`send()` method](/docs/api-reference/broadcasts/send-broadcast) to send or schedule an existing API-created Broadcast by ID. Broadcasts created using the Dashboard Broadcast editor cannot be sent with this endpoint.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.broadcasts.send(
  '559ac32e-9ef5-46fb-82a1-b76b840c0f7b',
  {
    scheduledAt: 'in 1 min',
  },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->broadcasts->send('559ac32e-9ef5-46fb-82a1-b76b840c0f7b', [
  'scheduled_at' => 'in 1 min',
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Broadcasts.SendParams = {
  "broadcast_id": "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
  "scheduled_at": "in 1 min"
}
resend.Broadcasts.send(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  broadcast_id: "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
  scheduled_at: "in 1 min"
}
Resend::Broadcasts.send(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	sendParams := &resend.SendBroadcastRequest{
		BroadcastId: "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
		ScheduledAt: "in 1 min",
	}

	client.Broadcasts.Send(sendParams)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::SendBroadcastOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let opts =
    SendBroadcastOptions::new("559ac32e-9ef5-46fb-82a1-b76b840c0f7b").with_scheduled_at("in 1 min");

  let _broadcast = resend.broadcasts.send(opts).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.services.broadcasts.model.SendBroadcastOptions;
import com.resend.services.broadcasts.model.SendBroadcastResponseSuccess;

Resend resend = new Resend("re_xxxxxxxxx");

SendBroadcastOptions params = SendBroadcastOptions.builder()
    .scheduledAt("in 1 min")
    .build();

SendBroadcastResponseSuccess data = resend.broadcasts().send(params,
    "498ee8e4-7aa2-4eb5-9f04-4194848049d1");
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// Send now
await resend.BroadcastSendAsync( new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ) );

// Send in 5 mins
await resend.BroadcastScheduleAsync(
    new Guid( "559ac32e-9ef5-46fb-82a1-b76b840c0f7b" ),
    DateTime.UtcNow.AddMinutes( 5 ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b/send' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "scheduled_at": "in 1 min"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend broadcasts send 559ac32e-9ef5-46fb-82a1-b76b840c0f7b --scheduled-at "in 1 min"
```

## Other ways to send

You can also send and manage Broadcasts using [Resend CLI commands](/docs/cli#broadcasts) and [AI building tools](/docs/ai-onboarding).

## API Reference

For complete API documentation, see the [Broadcasts API reference](/docs/api-reference/broadcasts/create-broadcast).


# Add Contacts
Source: https://resend.com/docs/dashboard/contacts/add-contacts

Learn how to add Contacts with Resend.

## Add Contacts

You can add a Contact in several different ways:

* [CSV upload](#add-contacts-by-uploading-a-csv)
* [API](#add-contacts-programmatically-via-api)
* [CLI](/docs/cli#contacts)
* [manually in the Dashboard](#add-contacts-manually)

> [!NOTE]
>
> Contacts are also created automatically when an
> [Automation](/docs/dashboard/automations/introduction) runs for an email address
> that doesn't yet exist in your Contact list.

### Add Contacts programmatically via API

When you create Contacts programmatically using the [Contacts API](/docs/api-reference/contacts/create-contact), an email address is the only required property. You can optionally pass [Contact properties available by default](/docs/dashboard/contacts/properties#included-properties), or any [custom Contact properties](/docs/dashboard/contacts/properties#add-custom-contact-properties) you have previously defined.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

resend.contacts.create({
  email: 'steve.wozniak@gmail.com',
  firstName: 'Steve',
  lastName: 'Wozniak',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contacts->create(
  parameters: [
    'email' => 'steve.wozniak@gmail.com',
    'first_name' => 'Steve',
    'last_name' => 'Wozniak',
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Contacts.CreateParams = {
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak",
}

resend.Contacts.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak",
}

Resend::Contacts.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateContactRequest{
		Email:        "steve.wozniak@gmail.com",
		FirstName:    "Steve",
		LastName:     "Wozniak",
		Unsubscribed: false,
	}

	client.Contacts.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateContactOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let contact = CreateContactOptions::new("steve.wozniak@gmail.com")
    .with_first_name("Steve")
    .with_last_name("Wozniak");

  let _contact = resend
    .contacts
    .create(contact)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.CreateContactOptions;
import com.resend.services.contacts.model.CreateContactResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateContactOptions params = CreateContactOptions.builder()
                .email("steve.wozniak@gmail.com")
                .firstName("Steve")
                .lastName("Wozniak")
                .build();

        CreateContactResponseSuccess data = resend.contacts().create(params);
    }
}
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/contacts' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak"
}'
```

Once a Contact is created, you can update it using the [update Contact](/docs/api-reference/contacts/update-contact) endpoint. There are also endpoints to [add the Contact to a Segment](/docs/api-reference/contacts/add-contact-to-segment) and to [update Topics for a Contact](/docs/api-reference/contacts/update-contact-topics).

### Add Contacts by uploading a .csv

If you already have a list of existing email addresses, you can add multiple Contacts at once by uploading a .csv file on the [Dashboard page](https://resend.com/audience).

**1. Go to the Dashboard page and select **Add contacts**.**

**2. Select **Import CSV**.**

**3. Upload your CSV file from your computer.**

**4. Map the fields you want to use.**

You can map the fields to the [included Contact
properties](/docs/dashboard/contacts/properties#included-properties) such as
`email` and `first_name`, or any [custom Contact
properties](/docs/dashboard/contacts/properties#add-custom-contact-properties)
you've already created.

**5. Optionally add the Contacts to an existing Segment.**

Broadcasts are usually sent to a Segment of your Contact list. Add a Segment
to determine which marketing emails you will send to the Contacts.

**6. Optionally add the Contacts to an existing Topic.**

You can subscribe your Contacts to one or more Broadcast Topics. They will
have the option to unsubscribe from your unsubscribe page.

**7. Select **Continue**, review the Contacts, and finish the upload.**

### Add Contacts manually

**1. Navigate to the Dashboard page.**

**2. Select **Add contacts**.**

**3. Select **Add Manually** from the dropdown.**

**4. Add the email address of the Contact in the text field (separated by commas or new lines for multiple Contacts).**

**5. Optionally add the new Contact to one or more existing Segments.**

> [!NOTE]
>
> An email address is the only required property for a new Contact. However,
> in most cases, a Contact must belong to a Segment in order to receive a
> Broadcast.

**6. Optionally add the new Contact to one or more existing Topics.**

**7. Confirm and click **Add**.**

## API Reference

For complete API documentation, see the [Contacts API reference](/docs/api-reference/contacts/create-contact).


# Contacts
Source: https://resend.com/docs/dashboard/contacts/introduction

An introduction to how your Contacts are organized and maintained in Resend.

## Global Contact list

Resend manages a global Contact list for your [Broadcasts](/docs/dashboard/broadcasts/introduction) with tools for viewing, organizing, and updating your subscribers.

Contacts are global entities linked to a specific email address. Add additional [Contact properties](#contact-properties), such as a first name, to store additional information and personalize your marketing emails.

Organize your Contacts into [Segments](#segments) for sending Broadcasts, and optionally use [Topics](#topics) to let your Contacts self-manage their receiving preferences.

Each Contact:

* is associated with a single email address
* can have custom properties
* can be in zero, one, or multiple Segments
* can opt in or out of Topics

> [!TIP]
>
> If you previously used our Audience model, learn how to [migrate to the new
> Contacts model](/docs/dashboard/contacts/migrating-from-audiences-to-segments).

## Contact features

For each Contact, you can:

* [View and manage](#manage-contacts) individual Contact details.
* Add and update [Contact properties](#contact-properties), including custom properties.
* Assign one or more Broadcast [Segments](#segments) for internal organization.
* Maintain a list of Broadcast [Topics](#topics) they have subscribed to.

![Properties](https://mintcdn.com/resend/2SHIfycCcJlAJEpt/images/audiences-properties-intro.png?fit=max\&auto=format\&n=2SHIfycCcJlAJEpt\&q=85\&s=001cb276f96ad54b6a64042eada0c9c3)

## Quickstart

In the [Dashboard](https://resend.com/audience), add Contacts manually by providing one or more email addresses, or [upload your existing Contacts](/docs/dashboard/contacts/add-contacts#add-contacts-by-uploading-a-csv) stored in a `.csv` file.

Add Contacts programmatically with the [Contacts API](/docs/dashboard/contacts/manage-contacts#add-contacts-programmatically-via-api) or [CLI commands](/docs/cli#contacts).

To add a single Contact manually in the Dashboard:

**1. Navigate to the Audience Dashboard page.**

**2. Select **Add contacts**.**

**3. Select **Add Manually** from the dropdown.**

**4. Add the email address of the Contact in the text field.**

**5. Add the new Contact to an existing Segment.**

> [!NOTE]
>
> An email address is the only required property for a new Contact. However,
> a Contact must belong to a Segment in order to receive a Broadcast.

**6. Confirm and click **Add**.**

See examples of [adding Contacts using other methods](/docs/dashboard/contacts/add-contacts).

## Choose your infrastructure

You can build and manage your Contact list entirely from the Resend Dashboard. This allows all members of your team to have full access to your Contact list and to perform any necessary maintenance.

To organize and update your Contacts and their properties from your application, you can use a variety of tools:

* [SDKs](/docs/sdks): manage with an SDK built for your language
* [Integrations](/docs/integrations): manage with a framework or tool you already use
* [API](/docs/api-reference/contacts/create-contact): manage with raw cURL calls
* [CLI](/docs/cli#contacts): manage from the terminal
* [MCP server](/docs/mcp-server): manage through your agent with MCP

You can also create [Automations](/docs/dashboard/automations/introduction) for repeatable actions involving Contacts such as adding new subscribers and updating your Contact list.

See how to use Resend's Contact features such as Segments and Topics in the [Contacts guides](#related-guides).

## Manage Contacts

After you have added Contacts, you'll be able to [view, manage and update Contacts](/docs/dashboard/contacts/manage-contacts) and their properties in the [Dashboard page](https://resend.com/audience). This allows all members of your team to maintain your Contact list and to perform any necessary maintenance such as [removing unsubscribed Contacts](/docs/dashboard/contacts/managing-unsubscribe-list).

You can also perform these actions programmatically through the [Contacts API](/docs/api-reference/contacts/create-contact), [Resend CLI commands](/docs/cli#contacts), [Automations](/docs/dashboard/automations/introduction), and [MCP server](/docs/mcp-server).

Learn more about [managing your Contacts](/docs/dashboard/contacts/manage-contacts) in the dedicated guide.

## Contact properties

All Contacts require a valid email address for the `email` property. In order to receive a Broadcast, a Contact will usually also be assigned to a Contact [Segment](#segments).

You can store additional information about your Contacts by adding values for other [Contact properties](/docs/dashboard/contacts/properties), including custom defined properties. Contact properties are useful for [personalizing your Broadcasts with dynamic content](/docs/dashboard/contacts/properties#use-contact-properties-in-broadcasts), such as greeting recipients by first name.

![Properties](https://mintcdn.com/resend/2SHIfycCcJlAJEpt/images/contact-properties.png?fit=max\&auto=format\&n=2SHIfycCcJlAJEpt\&q=85\&s=6eb917dc7ac58dd515c033cf443e0734)

## Segments

Segments are a tool to group and manage your Contacts for sending Broadcasts. Send Broadcasts to a defined segment of your Contact list to provide extra confidence that you are delivering emails to the intended audience.

**Segments are not visible to your Contacts.** They are only used for your own internal Contact organization. Your Contacts will never see the names of your Segments, and will not know which Segment(s) they belong to.

You can view, add, and manage your Segments in the [Dashboard](https://resend.com/audience) or with any of Resend's programmatic tools such as the [Segments API](/docs/api-reference/segments/create-segment), [Resend CLI commands](/docs/cli#segments), and [MCP](/docs/mcp-server).

You can also create [Automations](/docs/dashboard/automations/introduction) to add or remove Contacts from a Segment.

See how to perform common actions to manage your Segments in the dedicated [Segments guide](/docs/dashboard/contacts/manage-segments).

## Topics

You can choose to organize your marketing emails into distinct categories based on their subject matter or purpose by assigning a Topic to your Broadcast (e.g., `announcements`, `electronics`). Each Contact has a corresponding `topics` property that determines which Broadcasts they will be sent. If you do not use Topics, then Resend will send your email to every subscribed Contact in the Broadcast's Segment.

Unlike Segments, this optional Contact property can also be updated by subscriber action, and allows your users to self-manage their email preferences.

Scope sending a [Broadcast](/docs/dashboard/broadcasts/introduction) to a particular Topic, and subscribers will have the option to unsubscribe from that specific Topic only. This means that your users can continue to receive other emails that are relevant to them. They do not need to unsubscribe from your mailing list entirely.

Resend will handle the unsubscription workflow and update each Contact's list of subscribed Topics in response to user action. You can also manually update this Contact property on the user's behalf, or as part of Automation workflows.

You can view, add, and manage your Topics in the [**Audience** Dashboard](https://resend.com/audience) or with any of Resend's programmatic tools such as the [Topics API](/docs/api-reference/topics/create-topic), [Resend CLI commands](/docs/cli#topics), and [MCP](/docs/mcp-server).

See how to perform common actions to manage your Topics in the dedicated [Topics guide](/docs/dashboard/contacts/manage-topics).

## Topics vs Segments

Topics and Segments serve different purposes. They are complementary tools to ensure that your recipients are receiving the emails they want.

| Aspect | Topics | Segments |
| - | - | - |
| **Who controls it** | Your recipients | You (the sender) |
| **Visibility** | Shown on the unsubscribe page | Internal only (recipients never see them) |
| **Purpose** | Let users manage their preferences | Organize Contacts for targeted sending |
| **Example** | "Newsletter," "Product Updates" | "Enterprise customers," "Free trial users" |

## How Segments and Topics work together

Segments are **who you're sending a Broadcast to** and Topics are **what kind of Broadcast you're sending**.

When you send a Broadcast:

1. Choose a **Segment** as your recipients (your sender intent).
2. Label the content with a **Topic** (so the system can respect recipient preferences).
3. Everyone in the Segment receives the message except Contacts who are globally unsubscribed or opted out of that Topic.

For example, you might send a product announcement to your "Enterprise Customers" Segment, labeled with the "Product Updates" Topic. Recipients who previously unsubscribed from product updates are automatically excluded from delivery, even if they are in your "Enterprise Customers" Segment.

**Segments are for targeting. Topics are for protecting preferences.** They work together without competing.

## Related Guides

See how to use Resend's Contact management features.

> [card] [Add Contacts](/docs/dashboard/contacts/add-contacts)

> [card] [Manage Contacts](/docs/dashboard/contacts/manage-contacts)

> [card] [Contact Properties](/docs/dashboard/contacts/properties)

> [card] [Unsubscribe List](/docs/dashboard/contacts/managing-unsubscribe-list)

> [card] [Segments](/docs/dashboard/contacts/manage-segments)

> [card] [Topics](/docs/dashboard/contacts/manage-topics)

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

> [!NOTE]
>
> Currently, exports are limited to admin users of your team.

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

> [!NOTE]
>
> All exports your team creates are listed in the
> [Exports](https://resend.com/exports) page under **Settings** > **Team** >
> **Exports**. Select any export to view its details page. All members of your
> team can view your exports, but only admins can download the data.


# Managing Contacts
Source: https://resend.com/docs/dashboard/contacts/manage-contacts

Learn how to view, update, and delete your Contacts with Resend.

All members of your team can view and manage existing Contact details directly in the [Dashboard](https://resend.com/audience). You can also perform bulk actions (update Segments, subscribe to Topics) by selecting multiple Contacts.

To manage your Broadcast subscribers directly from your application, you can use the [Contacts API](/docs/api-reference/contacts/create-contact) to list, retrieve, update, and delete Contacts.

You can also manage Contacts using [Resend CLI commands](/docs/cli#contacts) and [MCP](/docs/mcp-server).

> [!TIP]
>
> If you previously used our Audience model, learn how to [migrate to the new
> Contacts model](/docs/dashboard/contacts/migrating-from-audiences-to-segments).

## Dashboard Views

The Resend Dashboard includes four different views of your Contacts:

* [Contacts](https://resend.com/audience/): individual email addresses
* [Properties](https://resend.com/audience/properties): custom properties for your Contacts
* [Segments](https://resend.com/audience/segments): groups of Contacts for your organization
* [Topics](https://resend.com/audience/topics): user-facing tools for managing email preferences

![Contacts](https://mintcdn.com/resend/2SHIfycCcJlAJEpt/images/audiences-contacts-intro.png?fit=max\&auto=format\&n=2SHIfycCcJlAJEpt\&q=85\&s=82101b2b495815ad50f8b7eb823876bd)

These areas provide different views of your marketing Contacts, and allow you to manage their properties and the emails they receive. You can also filter your list and perform bulk actions on multiple Contacts.

## View Contacts

See the name, Segments, status, and added date of all your Contacts from the [**Contacts** Dashboard view](https://resend.com/audience). You can additionally see filtered views of your Contacts by Segment and Topic, and manage your custom properties.

**1. Go to the **Contacts** Dashboard view.**

**2. Click on the Contact you want to view.**

**3. View the Contact details.**

Each Contact includes the metadata associated with the Contact, as well as a full history of all marketing interactions with the Contact.

![View Contact](https://mintcdn.com/resend/fJVhfUIq0WYU6NCn/images/contacts-view.png?fit=max\&auto=format\&n=fJVhfUIq0WYU6NCn\&q=85\&s=7d9d97f84af0603a528dd841a4f77637)

You can also [retrieve a single Contact](/docs/api-reference/contacts/get-contact) or [list all Contacts](/docs/api-reference/contacts/list-contacts) via the API or SDKs, or use [CLI commands to view your Contacts](/docs/cli#contacts).

## Edit Contacts

You can edit any Contact property (excluding the email address), assign the Contact to a [Segment](/docs/dashboard/contacts/introduction#segments) or [Topic](/docs/dashboard/contacts/introduction#topics), or unsubscribe the Contact from all Broadcasts.

**1. Go to the **Contacts** Dashboard view.**

**2. Click on the **More options** button next to any Contact and then **Edit contact**.**

**3. Edit the Contact details and choose **Save**.**

You can also [update a Contact via the API or SDKs](/docs/api-reference/contacts/update-contact) or with [CLI commands to update your Contacts](/docs/cli#contacts) using the `id` or `email` of the Contact.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.update({
  id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  // or: email: 'acme@example.com',
  unsubscribed: true,
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Update by contact id
$resend->contacts->update(
  idOrEmail: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  parameters: [
    'unsubscribed' => true
  ]
);

// Update by contact email
$resend->contacts->update(
  idOrEmail: 'acme@example.com',
  parameters: [
    'unsubscribed' => true
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Update by contact id
params: resend.Contacts.UpdateParams = {
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "unsubscribed": True,
}

resend.Contacts.update(params)

# Update by contact email
params: resend.Contacts.UpdateParams = {
  "email": "acme@example.com",
  "unsubscribed": True,
}

resend.Contacts.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Update by contact id
params = {
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "unsubscribed": true,
}

Resend::Contacts.update(params)

# Update by contact email
params = {
  "email": "acme@example.com",
  "unsubscribed": true,
}

Resend::Contacts.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
import "github.com/resend/resend-go/v4"

client := resend.NewClient("re_xxxxxxxxx")

// Update by contact id
params := &resend.UpdateContactRequest{
  Id:           "e169aa45-1ecf-4183-9955-b1499d5701d3",
  Unsubscribed: true,
}
params.SetUnsubscribed(true)

client.Contacts.Update(params)

// Update by contact email
params = &resend.UpdateContactRequest{
  Email:        "acme@example.com",
  Unsubscribed: true,
}
params.SetUnsubscribed(true)

client.Contacts.Update(params)
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::ContactChanges, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let changes = ContactChanges::new().with_unsubscribed(true);

  // Update by contact id
  let _contact = resend
    .contacts
    .update("e169aa45-1ecf-4183-9955-b1499d5701d3", changes.clone())
    .await?;

  // Update by contact email
  let _contact = resend
    .contacts
    .update("acme@example.com", changes)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.UpdateContactOptions;
import com.resend.services.contacts.model.UpdateContactResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateContactOptions params = UpdateContactOptions.builder()
                .id("e169aa45-1ecf-4183-9955-b1499d5701d3") // or: .email("acme@example.com")
                .unsubscribed(true)
                .build();

        UpdateContactResponseSuccess data = resend.contacts().update(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// By Id
await resend.ContactUpdateAsync(
    contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
    new ContactData()
    {
        FirstName = "Stevie",
        LastName = "Wozniaks",
        IsUnsubscribed = true,
    }
);

// By Email
await resend.ContactUpdateByEmailAsync(
    "acme@example.com",
    new ContactData()
    {
        FirstName = "Stevie",
        LastName = "Wozniaks",
        IsUnsubscribed = true,
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Update by contact id
curl -X PATCH 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "unsubscribed": true
}'

# Update by contact email
curl -X PATCH 'https://api.resend.com/contacts/acme@example.com' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "unsubscribed": true
}'
```

## Bulk Actions

You can perform actions on multiple Contacts at once in the Dashboard by selecting them from the [**Contacts** view](https://resend.com/audience).

**1. Go to the **Contacts** Dashboard view.**

**2. Select multiple Contacts by clicking the checkbox next to each Contact.**

**3. Click the **Edit** button in the bulk actions bar.**

**4. Choose an available action to apply to all Contacts.**

You can also delete multiple Contacts at once by clicking the **Delete** button in the bulk actions bar.

## Delete Contacts

**1. Go to the **Contacts** Dashboard view.**

**2. Click on the **More options** button next to any Contact and then **Delete contact**.**

**3. Confirm the deletion.**

You can also [delete a Contact](/docs/api-reference/contacts/delete-contact) via the API, SDKs, or CLI.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.remove({
  id: '520784e2-887d-4c25-b53c-4ad46ad38100',
  // or: email: 'acme@example.com',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Delete by contact id
$resend->contacts->remove(
  idOrEmail: '520784e2-887d-4c25-b53c-4ad46ad38100'
);

// Delete by contact email
$resend->contacts->remove(
  idOrEmail: 'acme@example.com'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Delete by contact id
resend.Contacts.remove(
  id="520784e2-887d-4c25-b53c-4ad46ad38100"
)

# Delete by contact email
resend.Contacts.remove(
  email="acme@example.com"
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Delete by contact id
Resend::Contacts.remove(
  id: "520784e2-887d-4c25-b53c-4ad46ad38100"
)

# Delete by contact email
Resend::Contacts.remove(
  email: "acme@example.com",
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
import "github.com/resend/resend-go/v4"

client := resend.NewClient("re_xxxxxxxxx")

// Delete by contact id
client.Contacts.Remove(&resend.RemoveContactOptions{
  Id: "520784e2-887d-4c25-b53c-4ad46ad38100",
})

// Delete by contact email
client.Contacts.Remove(&resend.RemoveContactOptions{
  Id: "acme@example.com",
})
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  // Delete by contact id
  let _deleted = resend
    .contacts
    .delete("520784e2-887d-4c25-b53c-4ad46ad38100")
    .await?;

  // Delete by contact email
  let _deleted = resend
    .contacts
    .delete("acme@example.com")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.RemoveContactOptions;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        // Delete by contact id
        resend.contacts().remove(RemoveContactOptions.builder()
                        .id("520784e2-887d-4c25-b53c-4ad46ad38100")
                        .build());

        // Delete by contact email
        resend.contacts().remove(RemoveContactOptions.builder()
                        .email("acme@example.com")
                        .build());
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// By Id
await resend.ContactDeleteAsync(
    contactId: new Guid( "520784e2-887d-4c25-b53c-4ad46ad38100" )
);

// By Email
await resend.ContactDeleteByEmailAsync(
    "acme@example.com"
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Delete by contact id
curl -X DELETE 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
     -H 'Authorization: Bearer re_xxxxxxxxx'

# Delete by contact email
curl -X DELETE 'https://api.resend.com/contacts/acme@example.com' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

## API Reference

For complete API documentation, see the [Contacts API reference](/docs/api-reference/contacts/create-contact).


# Managing Segments
Source: https://resend.com/docs/dashboard/contacts/manage-segments

Learn how to create, retrieve, and delete Segments.

Segments are used to organize your [Contacts](/docs/dashboard/contacts/introduction) into groups for sending [Broadcasts](/docs/dashboard/broadcasts/introduction). **Segments are not visible to your Contacts.** They are only used for your own internal Contact management.

## Create Segments

You can create Segments in the [Dashboard](https://resend.com/audience/segments), or programmatically from the [Segments API](/docs/api-reference/segments/create-segment), with a [Segments CLI command](/docs/cli#segments), or [MCP](/docs/mcp-server).

To create a Segment in the Resend Dashboard:

**1. Go to the **Segments** Dashboard view.**

**2. Select **Create Segment**.**

**3. Enter a name.**

Enter a name for your Segment that describes the Contacts in this group
(e.g., "newsletter subscribers", "free trial users").

**4. Click **Add** to confirm.**

## View Segments

The [**Segments** Dashboard view](https://resend.com/audience/segments) shows a list of all Segments in your account, when they were created, and how many Contacts are in each Segment.

## Edit Segments

Click the **More options**  menu next to each Segment to:

* edit the Segment name
* copy the Segment ID to your clipboard
* delete the Segment

Click on any Segment to view the list of Contacts that belong to that Segment.

You can also retrieve a single Segment, list of Segments, or the list of Contacts in a Segment, from the [Segments API](/docs/api-reference/segments/get-segment), with a [Segments CLI command](/docs/cli#segments), or [MCP](/docs/mcp-server).

## Updating the Segments of a Contact

A Contact can belong to multiple Segments. Because Segments are only used to organize your Contacts internally for sending Broadcasts, you do not need consent to add a user to a Segment.

You can add a Contact to a Segment via the Dashboard by [editing the Contact](/docs/dashboard/contacts/manage-contacts#edit-contacts) and choosing to add or remove Segments.

You can also use the [Contacts API](/docs/api-reference/contacts/add-contact-to-segment) or [Contacts CLI commands](/docs/cli#contacts) to add or remove Segments from a Contact's profile programmatically.

> [!NOTE]
>
> If a Contact's unsubscribed status is `true`, or the Contact is on the [Suppression List](/docs/dashboard/emails/email-suppressions), Resend will not send any emails to them, even if you have added them to a Segment.
>
> Regularly [review your unsubscribe list](/docs/dashboard/contacts/managing-unsubscribe-list) and remove recipients from your Contact list who no longer wish to receive your emails.

## Delete Segments

When you delete a Segment, no Contacts are deleted. The Segment is removed from your list, and from the `segments` property of all associated Contacts.

You can delete Segments in the [Dashboard](https://resend.com/audience/segments), or programmatically from the [Segments API](/docs/api-reference/segments/delete-segment), with a [Segments CLI command](/docs/cli#segments), or with [MCP](/docs/mcp-server).

To delete one or more Segments in the Dashboard:

**1. Go to the **Segments** Dashboard view.**

**2. Select the Segment(s) you want to delete by clicking the checkboxes next to each Segment.**

**3. Click **Delete** in the bottom action bar.**

**4. Type the Segment name (for single selection) or `DELETE N SEGMENTS` (for multiple) to confirm.**

**5. Press **Cmd+Enter** or click **Delete Segments** to complete.**

You can also use keyboard shortcuts:

* **Cmd+A** to select all Segments on the current page.
* **Backspace** to open the delete confirmation modal.

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

> [!NOTE]
>
> Currently, exports are limited to admin users of your team.

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

> [!NOTE]
>
> All exports your team creates are listed in the
> [Exports](https://resend.com/exports) page under **Settings** > **Team** >
> **Exports**. Select any export to view its details page. All members of your
> team can view your exports, but only admins can download the data.

## API Reference

For complete API documentation, see the [Segments API reference](/docs/api-reference/segments/create-segment).


# Topics
Source: https://resend.com/docs/dashboard/contacts/manage-topics

Learn how to create, view, delete, and manage Topics.

[Managing subscribers and unsubscribers](/docs/dashboard/contacts/managing-unsubscribe-list) is a critical part of any email implementation. Topics let your Contacts self-manage their marketing email preferences.

Instead of having a single unsubscribe option for all emails, Topics let your Contacts opt in or out of specific types of communications. This keeps them subscribed to the emails they want to receive.

When you send [Broadcasts](/docs/dashboard/broadcasts/introduction), you can optionally scope [sending with a particular Topic](#send-a-broadcast-with-a-topic). Not only do Topics help you send more precisely, but they also give your users more control over which emails they receive.

## Create a Topic

You can create a new Topic in the [Dashboard](https://resend.com/audience/topics) or programmatically from the [Topics API](/docs/api-reference/topics/create-topic), with a [Topics CLI command](/docs/cli#topics), or with [MCP](/docs/mcp-server).

To create a Topic in the Dashboard:

**1. Go to the **Topics** Dashboard view and click **Create Topic**.**

**2. Enter a name for your Topic.**

Choose something that will help your recipients decide whether they are
interested in receiving these emails, like "announcements" or "product
reviews."

**3. Optionally give your Topic a description.**

**4. Select **Opt-in** or **Opt-out** as the default subscription. This value cannot be changed later.**

<ul>
  <li>
    **Opt-in**: All Contacts will receive the email unless they have
    explicitly unsubscribed from that Topic.
  </li>

  <li>
    **Opt-out**: Subscribers will not receive the email unless they have
    explicitly subscribed to that Topic.
  </li>
</ul>

**5. Select **Public** or **Private** as the visibility.**

<ul>
  <li>
    **Private**: Only Contacts who are opted in to the Topic can see it
    on the unsubscribe page.
  </li>

  <li>
    **Public**: All Contacts can see the Topic on the unsubscribe page.
  </li>
</ul>

![Add Topic](https://mintcdn.com/resend/WTZjpSkJsZf7Ubl_/images/dashboard-topics-add.png?fit=max\&auto=format\&n=WTZjpSkJsZf7Ubl_\&q=85\&s=0f3f95d5f53d7628b164c04e28e7b4be)

## View all Topics

The [Topics tab of the Audience Dashboard page](https://resend.com/audience/topics) shows you all the Topics you have created along with their details.

![View All Topics](https://mintcdn.com/resend/WTZjpSkJsZf7Ubl_/images/dashboard-topics-view-all.png?fit=max\&auto=format\&n=WTZjpSkJsZf7Ubl_\&q=85\&s=172afe116b01792855837fc4f987a4be)

You can also [retrieve a single Topic](/docs/api-reference/topics/get-topic) or [list all your Topics](/docs/api-reference/topics/list-topics) via the API or [CLI](/docs/cli#topics).

## Edit Topic details

After creating a Topic, you can edit the following details:

* Name
* Description
* Visibility

To edit a Topic, click the **More options**  button and then **Edit Topic**.

![View edit topic](https://mintcdn.com/resend/WTZjpSkJsZf7Ubl_/images/dashboard-topics-edit.png?fit=max\&auto=format\&n=WTZjpSkJsZf7Ubl_\&q=85\&s=7f683116ec1dc37aa82c33de94bbd941)

You can also [update a Topic](/docs/api-reference/topics/update-topic) via the API.

> [!NOTE]
>
> You cannot edit the default subscription value after it has been created.

## Delete a Topic

You can delete a Topic by clicking the **More options**  button and then **Remove Topic**.

![Delete Topic](https://mintcdn.com/resend/WTZjpSkJsZf7Ubl_/images/dashboard-topics-remove.png?fit=max\&auto=format\&n=WTZjpSkJsZf7Ubl_\&q=85\&s=ad5a6bf19aa0f4d858959b91792de167)

You can also [delete a Topic](/docs/api-reference/topics/delete-topic) via the API.

## Send a Broadcast with a Topic

You can send with a Topic in the Broadcast editor from the Topics dropdown menu.

![Send emails with a Topic](https://mintcdn.com/resend/m2xttJpF68pi6Mw0/images/dashboard-broadcast-topics.png?fit=max\&auto=format\&n=m2xttJpF68pi6Mw0\&q=85\&s=95c0a3999269605a66102c15400c5a58)

You can also send with a Topic via the [Broadcast API](/docs/api-reference/broadcasts/create-broadcast).

## Topic Subscription Statuses

When you [view a Contact's details](/docs/dashboard/contacts/manage-contacts#view-contacts), you can see the list of Topics that they are subscribed to.

![Topic Subscription Statuses](https://mintcdn.com/resend/m2xttJpF68pi6Mw0/images/audiences-contacts-topics.png?fit=max\&auto=format\&n=m2xttJpF68pi6Mw0\&q=85\&s=56b25853b46fec447005f7aab32796fa)

You can also check a Contact's subscribed Topics [via the API or SDKs](/docs/api-reference/contacts/get-contact-topics) or with a [Contacts CLI command](/docs/cli#contacts).

## Updating a Topic Subscription for a Contact

When you [create new Topics](#create-a-topic), you can update the subscription preferences of your Contacts to include these Topics. A Contact can belong to multiple Topics, and Resend automatically provides an unsubscribe flow for users who decide to opt out of receiving these emails.

You can add a Contact to a Topic via the Dashboard by expanding the **More options**  and then **Edit Contact**. Add or remove Topics for a given Contact.

![Add Contact to Topic](https://mintcdn.com/resend/WTZjpSkJsZf7Ubl_/images/dashboard-save-contact-topic.png?fit=max\&auto=format\&n=WTZjpSkJsZf7Ubl_\&q=85\&s=66e212d282f450c371f42a1b214029cd)

You can also update a Topic subscription for a Contact [via the API or SDKs](/docs/api-reference/contacts/update-contact-topics) or with a [Contacts CLI command](/docs/cli#contacts).

## Bulk Subscribe to Topics

You can subscribe multiple Contacts to Topics in the [Dashboard](https://resend.com/audience/) at once:

**1. Go to the **Contacts** Dashboard view.**

**2. Select multiple Contacts by clicking the checkbox next to each Contact.**

**3. Click the **Edit** button in the bulk actions bar.**

**4. Select **Subscribe to Topics****

**5. Choose the Topics you want to subscribe the Contacts to.**

**6. Click **Subscribe****

Learn more about [bulk actions for Contacts](/docs/dashboard/contacts/manage-contacts#bulk-actions).

## API Reference

For complete API documentation, see the [Topics API reference](/docs/api-reference/topics/create-topic).


# Managing unsubscribed Contacts
Source: https://resend.com/docs/dashboard/contacts/managing-unsubscribe-list

Learn how to check and remove recipients who have unsubscribed from your marketing emails.

## Managing unsubscribes

A Contact's [**Subscribed** status](#subscription-statuses) is a global setting that enables or disables sending [Broadcasts](/docs/dashboard/broadcasts/introduction).

When you include [Resend's unsubscribe link placeholder](/docs/dashboard/broadcasts/editor#broadcast-unsubscribe-link) in your Broadcasts or Automations, Resend will automatically handle your Contact's unsubscribe flow for you and ensure that your Contact subscription statuses are up to date.

However, unsubscribed Contacts will not be removed from your account. Manually or programmatically deleting Contacts who no longer want to receive your emails is a key part of [maintaining audience hygiene](/docs/knowledge-base/audience-hygiene) and keeping your Contact list clean, valid, and engaged.

It's essential to update your Contact list when someone unsubscribes to maintain a good sender reputation.

Benefits of managing your unsubscribe list:

* reduces the likelihood of your emails being marked as spam
* improves deliverability for any other marketing or transactional emails you send

> [!TIP]
>
> Whenever possible, [add a Topic to your
> Broadcast](/docs/dashboard/contacts/introduction#topics). This allows your Contact
> to unsubscribe from only specific types of emails (instead of unsubscribing
> from all Broadcasts and Automation emails from your team).

You can also [include an unsubscribe link in transactional emails](/docs/dashboard/emails/add-unsubscribe-to-transactional-emails) where Resend does not manage your Contacts.

## Subscription Statuses

The [**Contacts** Dashboard view](https://resend.com/audience) shows the global subscription status of each Contact. This status determines whether or not Resend will send email to the Contact.

![Unsubscribe Statuses](https://mintcdn.com/resend/2SHIfycCcJlAJEpt/images/audiences-contacts-intro.png?fit=max\&auto=format\&n=2SHIfycCcJlAJEpt\&q=85\&s=82101b2b495815ad50f8b7eb823876bd)

* **Subscribed**: The Contact will receive Broadcasts sent to any Segment they belong to, and to any Topics they are subscribed to.
* **Unsubscribed**: The Contact will not receive Broadcasts or Automation emails, even if they are subscribed to individual Topics. Transactional emails sent through the API or SMTP are still delivered, unless the request includes a `topic_id` the Contact has opted out of.

## Delete unsubscribed Contacts

To delete your unsubscribed Contacts using the Dashboard:

**1. View your list of Contacts**

Navigate to the [**Contacts** Dashboard view](https://resend.com/audience).

**2. Filter by unsubscribed status**

Click on the **All subscriptions** filter next to the search bar, then
select **Unsubscribed**.

**3. Bulk delete**

Select all Contacts then click the **Delete** button in the bulk actions
bar.

You can also retrieve a list of unsubscribed Contacts to delete via the [Contacts API](/docs/api-reference/contacts/list-contacts) or with a [Contacts CLI command](/docs/cli#contacts).

## API Reference

For complete API documentation, see the [Contacts API reference](/docs/api-reference/contacts/list-contacts).


# Migrating from Audiences to Segments
Source: https://resend.com/docs/dashboard/contacts/migrating-from-audiences-to-segments

Learn how to migrate from Audiences to Segments

In November 2025, [Resend changed how Contacts are segmented](https://resend.com/blog/new-contacts-experience#segmenting-contacts). Before, each Contact was part of one Audience and if you created another Contact with the same email address in a different Audience, it would be a completely separate object.

Contacts are now independent of the groups they belong to, and the former Audiences are now called Segments. A Contact can be in zero, one or multiple Segments and count as only one Contact toward your Contact quota.

Contacts API endpoints that previously required an `audience_id` can now be used directly instead. The [Audiences API](https://resend.com/docs/api-reference/audiences/create-audience) is now deprecated and will be removed in the future.

## What changed

Resend now uses a **Global Contacts** model.

* **Before**: If a Contact with the same email appeared in multiple Segments, it was counted as multiple Contacts.
* **Now**: Each email address is treated as a single Contact across your team, even if it appears in multiple Segments.

The [current Contact model](/docs/dashboard/contacts/introduction) includes four concepts:

* **Contact**: a global entity linked to a specific email address.
* **Segment**: an internal segmentation tool for your team to organize sending.
* **Topic**: a user-facing tool for managing email preferences.
* **Contact properties**: a set of key-value pairs that can be used to store additional information about a Contact.

## Unsubscribing

Previously, when a Contact clicked "unsubscribe," their Contact status was marked as "Unsubscribed" only from the specific Audience used in that Broadcast.

Now, Contacts will see a preference page where they can:

* Unsubscribe from certain **Topics** (email's preference).
* Or unsubscribe from **everything** you send (update Contact status).

## What you should do

If you've been using Audiences for both segmentation and unsubscribes, we recommend switching your unsubscribe logic to **Topics**:

1. Create a Topic for each type of email you send.
2. Assign the right users to each Topic.
3. Use Segments purely for your internal organization.

With this setup, when you send a Broadcast, your users can choose which Topics to unsubscribe from, or opt out completely.

For details on the new API endpoints view:

* [Contacts](/docs/api-reference/contacts/create-contact)
* [Topics](/docs/api-reference/topics/create-topic)
* [Segments](/docs/api-reference/segments/create-segment)

## Additional Help

If you have a use case not covered here, [please reach out](https://resend.com/help) for assistance and a smooth transition.


# Contact properties
Source: https://resend.com/docs/dashboard/contacts/properties

Learn how to work with Contact properties with Resend.

## Contact properties

Contact properties can be used to store additional information about your Contacts and then [personalize your Broadcasts](#use-contact-properties-in-broadcasts) with dynamic content.

## Included properties

Each Contact includes the following attributes:

* `email`: The email address of the Contact. (required)
* `first_name`: The first name of the Contact.
* `last_name`: The last name of the Contact.
* `segments`: A list of [Segments](/docs/dashboard/contacts/introduction#segments) the Contact belongs to.
* `topics`: A list of [Topics](/docs/dashboard/contacts/introduction#topics) the Contact subscribes to.
* `unsubscribed`: Whether the Contact is unsubscribed from all Broadcasts.
* `properties`: An object of custom-defined properties, where each value includes the property's `value` and `type`.

## Manage Contact properties

You can view, add, and manage your Contact properties in the [**Properties** Dashboard view](https://resend.com/audience/properties) or programmatically with the [Contact properties API](/docs/api-reference/contact-properties/create-contact-property), [Resend CLI commands](/docs/cli#contact-properties), and [MCP](/docs/mcp-server).

You can also create [Automations](/docs/dashboard/automations/introduction) to update Contact properties.

## Add Custom Contact properties

You can create additional custom Contact properties for your Contacts to store additional information. These properties can be used to personalize your Broadcasts across all Segments.

Each Contact Property has a key, a value, and optional fallback value.

* `key`: The key of the property (must be alphanumeric and underscore only, max 50 characters). This is case sensitive.
* `value`: The value of the property (may be a `string` or `number`).
* `fallback_value`: The fallback value of the property (must match the type of the property).

<video />

You can also create Contact properties [via the API or SDKs](/docs/api-reference/contact-properties/create-contact-property).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contactProperties.create({
  key: 'company_name',
  type: 'string',
  fallbackValue: 'Acme Corp',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contactProperties->create([
  'key' => 'company_name',
  'type' => 'string',
  'fallback_value' => 'Acme Corp',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = 're_xxxxxxxxx'

params: resend.ContactProperties.CreateParams = {
    "key": "company_name",
    "type": "string",
    "fallback_value": "Acme Corp",
}

contact_property = resend.ContactProperties.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

property = Resend::ContactProperties.create({
  key: "company_name",
  type: "string",
  fallback_value: "Acme Corp"
})
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	apiKey := "re_xxxxxxxxx"

	client := resend.NewClient(apiKey)

	params := &resend.CreateContactPropertyRequest{
		Key:           "company_name",
		Type:          "string",
		FallbackValue: "Acme Corp",
	}

	property, err := client.ContactProperties.CreateWithContext(ctx, params)
	if err != nil {
		panic(err)
	}
	fmt.Println(property)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateContactPropertyOptions, PropertyType},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let contact_property = CreateContactPropertyOptions::new("company_name", PropertyType::String)
    .with_fallback("Acme Corp");

  let _contact_property = resend.contacts.create_property(contact_property).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.contactproperties.model.CreateContactPropertyOptions;

public class Main {
  public static void main(String[] args) throws ResendException {
    Resend resend = new Resend("re_xxxxxxxxx");

    CreateContactPropertyOptions options = CreateContactPropertyOptions.builder()
      .key("company_name")
      .type("string")
      .fallbackValue("Acme Corp")
      .build();

    resend.contactProperties().create(options);
  }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactPropCreateAsync( new ContactPropertyData() {
  Key = "company_name",
  PropertyType = ContactPropertyType.String,
  DefaultValue = "Acme Corp",
} );
Console.WriteLine( "Prop Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/contact-properties' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "key": "company_name",
  "type": "string",
  "fallback_value": "Acme Corp"
}'
```

## Add properties to a Contact

When you create a Contact property with a fallback value, that default is used for Contacts that do not have a custom value for the property. If no fallback is provided, the Contact will not have a value for that property.

To update this value for a Contact in the [Dashboard](https://resend.com/audience):

**1. Go to the **Contacts** Dashboard view.**

**2. Click the **More options** button and then **Edit Contact**.**

**3. Add the property key and value.**

**4. Click the **Save** button.**

<video />

## Add or update property values programmatically

You can add custom property values to a Contact when you [create a Contact with the API](/docs/api-reference/contacts/create-contact) or [from the terminal with a CLI command](/docs/cli#contacts).

```ts Node.js {10-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.create({
  email: 'steve.wozniak@gmail.com',
  firstName: 'Steve',
  lastName: 'Wozniak',
  unsubscribed: false,
  properties: {
    company_name: 'Acme Corp',
  },
});
```

```php PHP {9-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->contacts->create(
  parameters: [
    'email' => 'steve.wozniak@gmail.com',
    'first_name' => 'Steve',
    'last_name' => 'Wozniak',
    'unsubscribed' => false,
    'properties' => [
      'company_name' => 'Acme Corp',
    ]
  ]
);
```

```python Python {10-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Contacts.CreateParams = {
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak",
  "unsubscribed": False,
  "properties": {
    "company_name": "Acme Corp"
  }
}

resend.Contacts.create(params)
```

```ruby Ruby {10-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak",
  "unsubscribed": false,
  "properties": {
    "company_name": "Acme Corp",
  }
}

Resend::Contacts.create(params)
```

```go Go {10-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
import "github.com/resend/resend-go/v4"

client := resend.NewClient("re_xxxxxxxxx")

params := &resend.CreateContactRequest{
  Email:        "steve.wozniak@gmail.com",
  FirstName:    "Steve",
  LastName:     "Wozniak",
  Unsubscribed: false,
  Properties: map[string]interface{} {
    "company_name": "Acme Corp",
  },
}

client.Contacts.Create(params)
```

```rust Rust {12-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateContactOptions, Resend, Result};
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let contact = CreateContactOptions::new("steve.wozniak@gmail.com")
    .with_first_name("Steve")
    .with_last_name("Wozniak")
    .with_unsubscribed(false)
    .with_properties(HashMap::from([(
      "company_name".to_string(),
      "Acme Corp".to_string(),
    )]));

  let _contact = resend.contacts.create(contact).await?;

  Ok(())
}
```

```java Java {15-16} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.CreateContactOptions;
import com.resend.services.contacts.model.CreateContactResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateContactOptions params = CreateContactOptions.builder()
                .email("steve.wozniak@gmail.com")
                .firstName("Steve")
                .lastName("Wozniak")
                .unsubscribed(false)
                .properties(java.util.Map.of("company_name", "Acme Corp"))
                .build();

        CreateContactResponseSuccess data = resend.contacts().create(params);
    }
}
```

```csharp .NET {12-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.ContactAddAsync(
    new ContactData()
    {
        Email = "steve.wozniak@gmail.com",
        FirstName = "Steve",
        LastName = "Wozniak",
        IsUnsubscribed = false,
        Properties = new Dictionary<string, object?> {
          { "company_name", "Acme Corp" }
        }
    }
);
Console.WriteLine( "Contact Id={0}", resp.Content );
```

```bash cURL {9-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/contacts' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "email": "steve.wozniak@gmail.com",
  "first_name": "Steve",
  "last_name": "Wozniak",
  "unsubscribed": false,
  "properties": {
    "company_name": "Acme Corp",
  }
}'
```

You can also update a Contact to add or change a property value [using the update Contact endpoint](/docs/api-reference/contacts/update-contact) or [CLI command](/docs/cli#contacts).

```ts Node.js {8-10} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.contacts.update({
  id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  // or: email: 'acme@example.com',
  properties: {
    company_name: 'Acme Corp',
  },
});
```

```php PHP {7-9, 17-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Update by contact id
$resend->contacts->update(
  idOrEmail: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  parameters: [
    'properties' => [
      'company_name' => 'Acme Corp',
    ]
  ]
);

// Update by contact email
$resend->contacts->update(
  idOrEmail: 'acme@example.com',
  parameters: [
    'properties' => [
      'company_name' => 'Acme Corp',
    ]
  ]
);
```

```python Python {8-10, 18-20} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Update by contact id
params: resend.Contacts.UpdateParams = {
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "properties": {
    "company_name": "Acme Corp",
  }
}

resend.Contacts.update(params)

# Update by contact email
params: resend.Contacts.UpdateParams = {
  "email": "acme@example.com",
  "properties": {
    "company_name": "Acme Corp",
  }
}

resend.Contacts.update(params)
```

```ruby Ruby {8-10, 18-20} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Update by contact id
params = {
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "properties": {
    "company_name": "Acme Corp",
  }
}

Resend::Contacts.update(params)

# Update by contact email
params = {
  "email": "acme@example.com",
  "properties": {
    "company_name": "Acme Corp",
  }
}

Resend::Contacts.update(params)
```

```go Go {8-10, 19-21} theme={"theme":{"light":"github-light","dark":"vesper"}}
import "github.com/resend/resend-go/v4"

client := resend.NewClient("re_xxxxxxxxx")

// Update by contact id
params := &resend.UpdateContactRequest{
  Id:           "e169aa45-1ecf-4183-9955-b1499d5701d3",
  Properties: map[string]interface{}{
    "company_name": "Acme Corp",
  },
}
params.SetUnsubscribed(true)

client.Contacts.Update(params)

// Update by contact email
params = &resend.UpdateContactRequest{
  Email:        "acme@example.com",
  Properties: map[string]interface{}{
    "company_name": "Acme Corp",
  },
}
params.SetUnsubscribed(true)

client.Contacts.Update(params)
```

```rust Rust {8-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::ContactChanges, Resend, Result};
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let changes = ContactChanges::new().with_properties(HashMap::from([(
    "company_name".to_string(),
    "Acme Corp".to_string(),
  )]));

  // Update by contact id
  let _contact = resend
    .contacts
    .update("e169aa45-1ecf-4183-9955-b1499d5701d3", changes.clone())
    .await?;

  // Update by contact email
  let _contact = resend
    .contacts
    .update("acme@example.com", changes)
    .await?;

  Ok(())
}
```

```java Java {12} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.contacts.model.UpdateContactOptions;
import com.resend.services.contacts.model.UpdateContactResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateContactOptions params = UpdateContactOptions.builder()
                .id("e169aa45-1ecf-4183-9955-b1499d5701d3") // or: .email("acme@example.com")
                .properties(java.util.Map.of("company_name", "Acme Corp"))
                .build();

        UpdateContactResponseSuccess data = resend.contacts().update(params);
    }
}
```

```csharp .NET {12-14, 25-27} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

// By Id
await resend.ContactUpdateAsync(
    contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
    new ContactData()
    {
        FirstName = "Stevie",
        LastName = "Wozniaks",
        Properties = new Dictionary<string, object?> {
          { "company_name", "Acme Corp" }
        }
    }
);

// By Email
await resend.ContactUpdateByEmailAsync(
    "acme@example.com",
    new ContactData()
    {
        FirstName = "Stevie",
        LastName = "Wozniaks",
        Properties = new Dictionary<string, object?> {
          { "company_name", "Acme Corp" }
        }
    }
);
```

```bash cURL {6-8, 16-18} theme={"theme":{"light":"github-light","dark":"vesper"}}
# Update by contact id
curl -X PATCH 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "properties": {
    "company_name": "Acme Corp",
  }
}'

# Update by contact email
curl -X PATCH 'https://api.resend.com/contacts/acme@example.com' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "properties": {
    "company_name": "Acme Corp",
  }
}'
```

When you create or update a Contact with properties, the properties are added to the Contact only if the property key already exists and the value type is valid.

If the properties don't exist, or the values are of the wrong type, they are not added to the Contact and the call fails. An error is returned.

You can [list all Contact properties with the API](/docs/api-reference/contact-properties/list-contact-properties) to see and verify all available properties.

## Use Contact properties in Broadcasts

You can use Contact properties in your Broadcasts to [personalize your emails](/docs/dashboard/broadcasts/editor#personalize-your-content).

<video />

You can also use Contact properties in your Broadcast HTML and Text content when you [create a Broadcast using the API or SDKs](/docs/api-reference/broadcasts/create-broadcast).

## API Reference

For complete API documentation, see the [Contact properties API reference](/docs/api-reference/contact-properties/create-contact-property).


# Implementing BIMI
Source: https://resend.com/docs/dashboard/domains/bimi

Set up BIMI to gain brand recognition by displaying your logo in the inbox.

## Prerequisites

To get the most out of this guide, you will need to:

* Establish verifiable use of your logo
  * Obtain a registered trademark for your logo
  * Or, use your logo for over one year
* [Add a DMARC record on your domain](/docs/dashboard/domains/dmarc)

## What is BIMI?

BIMI ([Brand Indicators for Message Identification](https://bimigroup.org/)) is a standard that allows you to specify a logo (and sometimes a checkmark) to display next to your email in the inbox. These indicators can increase brand recognition and trust and improve engagement.

![bimi-example](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/bimi-example.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=7cad76755f1a51e03465d90d413df055)

Though this standard is newer, most major mailbox providers now support it. This gives BIMI adoption a competitive edge for brand recognition in the inbox. Most mailbox providers show brand indicators for those who purchase a certificate, of which there are two types: a Common Mark Certificate (CMC) and a Verified Mark Certificate (VMC).

Here's an overview of current email client support:

| Client | BIMI w/a CMC | BIMI w/a VMC | BIMI w/out a VMC or CMC |
| - | - | - | - |
| [Apple Mail](https://support.apple.com/en-us/108340) | X | ✓ | X |
| [Gmail](https://support.google.com/a/answer/10911320) | ✓ | ✓ | X |
| Outlook | X | X | X |
| [Yahoo](https://senders.yahooinc.com/bimi/) | ✓ | ✓ | ✓ |

## Implementing BIMI

**1. Configure DMARC**

> [!NOTE]
>
> If you haven't set up DMARC yet, follow our [DMARC Setup
> Guide](/docs/dashboard/domains/dmarc).

BIMI requires a DMARC policy of `p=quarantine;` or `p=reject;`. This policy assures that your emails are properly authenticated and that no one else can spoof your domain and send them with your logo.

Here's an overview of the required parameters:

| Parameter | Purpose | Required Value |
| - | - | - |
| `p` | Policy | `p=quarantine;` or `p=reject;` |
| `pct` | Percentage | `pct=100;` |

Here is an example of an adequate DMARC record:

```
"v=DMARC1; p=quarantine; pct=100; rua=mailto:dmarcreports@example.com"
```

> [!NOTE]
>
> For BIMI on a subdomain, the root or APEX domain must also have a DMARC policy
> of `p=quarantine` or `p=reject` in addition to the subdomain. If not, the
> subdomain will not be compliant to display a BIMI logo.

**2. Establish verifiable use of your logo**

To display your logo in most email clients using BIMI, you need to prove ownership of your logo by obtaining a mark certificate. This process is similar to acquiring an SSL certificate for your website. You can purchase a mark certificate from one of the following [authorized mark verifying authorities](https://bimigroup.org/vmc-issuers/):

* [DigiCert](https://www.digicert.com/tls-ssl/verified-mark-certificates)
* [GlobalSign](https://www.globalsign.com/)
* [SSL.com](https://www.ssl.com/)

There are two possible mark Certificate's to verify the use of your logo:

* **Verified Mark Certificate (VMC)**: A certificate issued by a Certificate Authority (CA) that is used to verify that you are the owner of the logo you are trying to display. A VMC is available if you have a trademark of your logo. With a VMC, Gmail will display a blue checkmark.
* **Common Mark Certificate (CMC)**: A certificate also issued by Certificate Authority (CA) to verify you. A CMC is available to you if you can establish that you’ve used your logo for one year. Only Gmail and Yahoo support a CMC.

A VMC offers the widest email client support, though the barrier of a trademark means a CMC is an easier path if you have established use of your logo for one year.

Here are a some things to know before starting the certificate purchase process:

* If you don't hold a trademark for your logo or have not used your logo for a year, you will not be able to purchase a certificate.
* The process can take weeks, so start early and respond to their requests quickly.
* You will need to provide a [SVG Tiny P/S formatted logo](https://bimigroup.org/creating-bimi-svg-logo-files/).
* You will need to prove you own the domain by adding a DNS record.
* You will need to prove you are the owner of the trademark or logo by providing identification.
* You will need publicly available proof that your business exists. For newer startups, recommend [Yellow Pages](https://marketing.yellowpages.com/en/) or [Google Business Profiles](https://support.google.com/business/answer/3039617?hl=en) as the easiest method for proving your existence

**3. Set your BIMI DNS Record**

Once you have your VMC, you can set your BIMI DNS record. This TXT record points to the location of your VMC and your logo.

| Name | Type | Value |
| - | - | - |
| default.\_bimi | TXT | v=BIMI1; l=link\_to\_logo; a=link\_to\_certificate; |

Here is an example of a BIMI record:

```
v=BIMI1; l=https://vmc.digicert.com/00-00.svg; a=https://vmc.digicert.com/00-00.pem;
```

> [!TIP]
>
> Ensure your logo uses an HTTPS URL. Mailbox providers will not display the
> logo if served from an HTTP URL.

It contains a publicly and programmatically accessible link to your verified logo (.svg) and a link to your VMC (.pem).

To confirm that your BIMI record is published correctly, the [BIMI working group offers a tool](https://bimigroup.org/bimi-generator/) to check it.

It often takes a few days for your logo to display in inboxes after this record propagates. Mailbox providers will also conditionally decide to show the logo based on the domain's sending email volume and reputation. A domain with a high spam or bounce rate may not have their avatar displayed.

## Reference

| Parameter | Purpose | Example |
| - | - | - |
| `v` | The version of BIMI | `v=BIMI1` |
| `l` | Logo | `l=https://vmc.digicert.com/00-00.svg` |
| `a` | Certificate | `a=https://vmc.digicert.com/00-00.pem` |
| `s` | Selector | `s=springlogo` |

> [!TIP]
>
> The BIMI standard allows for multiple logos using the [selector
> parameter](https://bimigroup.org/how-and-why-to-implement-bimi-selectors/).

> [!NOTE]
>
> Having issues setting up BIMI? [We can help](https://resend.com/help).


# Claiming a domain
Source: https://resend.com/docs/dashboard/domains/claim

Claim a domain that is already verified by another team.

A domain can only be active on one Resend team at a time. When you try to add a domain that has already been verified by another team, Resend will alert you that the domain is already in use.

* **If you own the team where the domain is registered**, delete the domain so you can add it in your desired team.

* **If you do not have access to the team where the domain is registered**, you can prove ownership and [claim the domain](#claim-a-domain) by adding a TXT record to your DNS and then verifying the claim.

## Why This Happens

Common reasons a domain you own may already be registered:

* A team member or contractor added it to a separate Resend team.
* You are logged into a different Resend team than the one where the domain was originally added.

Before claiming a domain, check with your team members or in your other teams to see if you can locate the verified domain and [transfer it between teams](/docs/dashboard/domains/manage-domains#transfer-a-domain-between-teams) instead.

## Claim a domain

Claim a domain by adding a TXT record to your DNS, or do it in one click via DomainConnect for supported registrars.

This record is provided along with the alert in your Dashboard, or when you [use the Domains API](#using-the-domains-API) and call the [**Claim Domain** API endpoint](/docs/api-reference/domains/claim-domain).

![Domain claim](https://mintcdn.com/resend/zovbQ7LtiJotsf8X/images/claim-domain-1.png?fit=max\&auto=format\&n=zovbQ7LtiJotsf8X\&q=85\&s=e585d0a2eb204c15fa59b3998b6bd581)

After adding the TXT record, return to the dashboard and click **I've added the records**.

Resend verifies the domain ownership, releases the domain from the previous team, and shows you the records to add to your DNS for sending or receiving. See the full steps to [add a domain](/docs/add-a-domain).

## Using the Domains API

**1. Start a claim**

Call [Claim Domain](/docs/api-reference/domains/claim-domain) with the domain
name. Resend creates a placeholder domain on your team and returns a
`domain_claim` containing a TXT `record` to add to your DNS.

**2. Add the TXT record**

Add the returned TXT record at your DNS provider. It proves you control the
domain.

**3. Verify the claim**

Call [Verify Domain Claim](/docs/api-reference/domains/verify-domain-claim).
Resend checks the TXT record and runs ownership-safety checks before
transferring the domain.

**4. Track the status**

Poll [Retrieve Domain Claim](/docs/api-reference/domains/get-domain-claim) until
the claim reaches `completed`.

## Claim status

| Status | Meaning |
| - | - |
| `pending` | Waiting for DNS verification. |
| `verified` | DNS proof accepted; the transfer is in progress. |
| `completed` | The domain now belongs to your team. |
| `blocked` | A safety check blocked the claim — see `blocked_reason`. |
| `expired` | The claim window passed before it completed. |
| `superseded` | A newer claim replaced this one. |
| `canceled` | The claim was canceled. |
| `failed` | The claim could not be completed. |

When a claim is `blocked`, `blocked_reason` explains why: `grace_period`,
`recent_owner_activity`, or `pending_scheduled_emails`.

## Canceling a claim

Cancel a pending claim initiated with the API by deleting its placeholder domain with
[Delete Domain](/docs/api-reference/domains/delete-domain), using the `domain_id`
from the `domain_claim` object.

## Support

If you can't locate your domain in another team, and you are unable to successfully claim the domain, contact [Resend support](https://resend.com/help) and share the domain name so the team can help you recover access.


# Configure a custom Return Path
Source: https://resend.com/docs/dashboard/domains/custom-return-path

Learn how to configure a custom Return Path for your verified domain in Resend.

By default, Resend uses the `send` subdomain for the Return-Path address.

> [!NOTE]
>
> Domains that show `CNAME` records for sending use your Return-Path subdomain
> for one record and an `r`-prefixed sibling for the other. With a Return-Path
> of `outbound`, you'll be shown records for both `outbound.example.com` and
> `routbound.example.com`, and both need to be added for the domain to fully
> verify.

You can provide a custom Return-Path address when you [add a new domain in the Dashboard](/docs/add-a-domain) under **Advanced options**, or by setting the optional `custom_return_path` parameter when [creating a domain via the API](/docs/api-reference/domains/create-domain) or with [the `domains create` CLI command](/docs/cli#domains).

> [!NOTE]
>
> The Return-Path is set when the domain is created and cannot be changed
> afterwards, so `custom_return_path` is not accepted by the [Update
> Domain](/docs/api-reference/domains/update-domain) endpoint. To use a different
> Return-Path subdomain, delete the domain and add it again with the new value.

![Custom Return Path](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-custom-return-path.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=569a75fc160aad18116efc93bcebe148)

For the API, optionally pass the custom return path parameter.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

resend.domains.create({ name: 'example.com', customReturnPath: 'outbound' });
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->create([
  'name' => 'example.com',
  'custom_return_path' => 'outbound'
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Domains.CreateParams = {
  "name": "example.com",
  "custom_return_path": "outbound"
}

resend.Domains.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "example.com",
  custom_return_path: "outbound"
}
domain = Resend::Domains.create(params)
puts domain
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateDomainRequest{
		Name:             "example.com",
		CustomReturnPath: "outbound",
	}

	client.Domains.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateDomainOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _domain = resend
    .domains
    .create(CreateDomainOptions::new("example.com").with_custom_return_path("outbound"))
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.domains.model.CreateDomainOptions;
import com.resend.services.domains.model.CreateDomainResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateDomainOptions params = CreateDomainOptions
                .builder()
                .name("example.com")
                .customReturnPath("outbound")
                .build();

        CreateDomainResponse domain = resend.domains().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.DomainAddAsync( new DomainAddData {
   DomainName = "example.com",
   CustomReturnPath = "outbound"
} );
Console.WriteLine( "Domain Id={0}", resp.Content.Id );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/domains' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "example.com",
  "custom_return_path": "outbound"
}'
```

Custom return paths must adhere to the following rules:

* Must be 63 characters or less.
* Must start with a letter, and end with a letter or number.
* Must contain only letters, numbers, and hyphens.

Avoid setting values that could undermine credibility (e.g. `testing`), as they may be exposed to recipients in some email clients.


# Implementing DMARC
Source: https://resend.com/docs/dashboard/domains/dmarc

Implement DMARC to build trust in your domain and protect against email spoofing and unauthorized use of your domain in email messages.

## Prerequisites

Since DMARC relies on DKIM and SPF, first ensure your existing emails are passing SPF and DKIM.

* DKIM verifies the email wasn't altered in transit using cryptographic authentication.
* SPF authorizes IP addresses to send email for a domain.

If you have a [verified](/docs/dashboard/domains/introduction) domain with Resend, it means you are already passing SPF and DKIM.

> [!NOTE]
>
> For more details on understanding DMARC reports, see our [guide on how to read
> a DMARC report](https://resend.com/blog/how-to-read-a-dmarc-report). You can
> also use Resend's [DMARC analyzer](/docs/dmarc-analyzer) to visualize your DMARC
> reports.

## What is DMARC?

DMARC ([Domain-based Message Authentication, Reporting, and Conformance](https://dmarc.org/overview/)) is an email authentication protocol that instructs mail servers what to do if an email message fails SPF and DKIM, preventing email spoofing (forged headers). DMARC is added to a domain through a TXT record added to the domain at `_dmarc`.

By preventing spoofing, a domain can build trust with mailbox providers, as it allows them to verify that emails are authorized to send on behalf of that domain.

An email must pass either SPF or DKIM checks (but not necessarily both) to achieve DMARC compliance and be considered authenticated. A message fails DMARC if both SPF and DKIM fail on the message.

## Implementing DMARC

**1. Add a TXT \_dmarc Record**

To start, add a flexible DMARC record to your domain.

| Name | Type | Value |
| - | - | - |
| \_dmarc.example.com | TXT | `v=DMARC1; p=none; rua=mailto:dmarcreports@example.com;` |

This record is specifying a few parameters (see [Reference](#reference) section for more details):

* `v` - Version:
  This is the version of DMARC
* `p` - Policy:
  This is telling the inbox how to process messages that fail DMARC. Options are `none`, `quarantine`, `reject`. It's a best practice to use `quarantine` or `reject`, but only do this once you know your messages are delivering and fully passing DMARC.
* `rua` - Reporting URI of Aggregate:
  Provide a **valid address** that can receive email. The address can be a different domain than the one on which you set the DMARC policy. The aggregate report comes as an email with a `.xml` file attached that shares the IP sources of your messages and if they passed SPF or DKIM.

To ensure you don't accidentally introduce breaking changes to your email sending, we suggest starting with a policy of `p=none;` before moving to a stricter policy.

**2. Test to Confirm Delivery and Passing**

To test emails, send an email from all the applications and services your domain uses. Confirm that the messages are delivered to the inbox and that the headers show DMARC passing. Spending a few at this step is a good rule of thumb to ensure you're checking all sources of email from your domain and catch email that is sent at a different cadence than daily.

To confirm DMARC passed, you can inspect the email headers and confirm there is `dmarc=pass`.

> [!TIP]
>
> Gradually identify email sources using tools like [Google Postmaster
> Tools](https://gmail.com/postmaster/), which provides DKIM/SPF feedback.
> [DMARC monitoring
> services](https://dmarc.org/resources/products-and-services/) can aggregate
> your email sources by collecting DMARC reports, helping you discover any
> services sending email on your domain's behalf.

**3. Upgrade Policy**

Once you have verified DMARC is passing across all your sending, upgrade your Policy to `p=quarantine;`. This policy gives mailbox providers greater confidence in your domain since your domain only allows authenticated email.

Update the value of your existing `_dmarc` TXT record to use a stricter policy:

| Name | Type | Value |
| - | - | - |
| \_dmarc.example.com | TXT | `v=DMARC1; p=quarantine; rua=mailto:dmarcreports@example.com;` |

Once you're confident that all legitimate email is passing DMARC, you can further tighten the policy to `reject`:

| Name | Type | Value |
| - | - | - |
| \_dmarc.example.com | TXT | `v=DMARC1; p=reject; rua=mailto:dmarcreports@example.com;` |

> [!NOTE]
>
> While tightening your policy, it's important to have visibility into your
> DMARC failures to ensure you're not blocking legitimate email. We recommend
> adding aggregate reporting (`rua`) to your DMARC record to help you monitor
> and troubleshoot DMARC failures. For help analyzing your DMARC reports, see
> our [guide on how to read a DMARC
> report](https://resend.com/blog/how-to-read-a-dmarc-report) or use Resend's
> [DMARC analyzer](/docs/dmarc-analyzer).

Here is a summary of the available policies and their behavior:

| Policy | Value |
| - | - |
| p=none; | Allow all email. Monitoring for DMARC failures. |
| p=quarantine; | Send messages that fail DMARC to the spam folder |
| p=reject; | Bounce delivery of emails that fail DMARC. |

Once your policy is `p=quarantine;` or `p=reject;` you can explore setting up [BIMI](/docs/dashboard/domains/bimi), which can provide established brands even greater sending credibility by displaying a logo as an avatar in an email client.

## Reference

> [!TIP]
>
> While the DMARC protocol includes both `pct` and `ruf` parameters, they are
> not widely followed by mailbox providers. These settings may not be respected
> or followed.

| Parameter | Purpose | Example |
| - | - | - |
| `v` | Protocol version | `v=DMARC1` |
| `pct` | Percentage of messages subjected to filtering | `pct=20` |
| `ruf` | Reporting URI for forensic reports | `ruf=mailto:authfail@example.com` |
| `rua` | Reporting URI of aggregate reports | `rua=mailto:aggrep@example.com` |
| `p` | Policy for organizational domain | `p=quarantine` |
| `sp` | Policy for subdomains of the OD | `sp=reject` |
| `adkim` | Alignment mode for DKIM | `adkim=s` |
| `aspf` | Alignment mode for SPF | `aspf=r` |

> [!NOTE]
>
> Having issues setting up DMARC? [We can help](https://resend.com/help).


# Verified Domains
Source: https://resend.com/docs/dashboard/domains/introduction

An introduction to verified domains in Resend.

## Verified domains

Resend sends emails using a domain you own (i.e., not a shared or public domain). You must [add and verify at least one domain](/docs/add-a-domain) to send emails with Resend. You can optionally [configure your domain to receive emails](/docs/dashboard/receiving/custom-domains).

You can add and verify multiple [subdomains](#subdomains) from the same root domain (e.g., `newsletter.example.com` and `account.example.com`) to identify different sending purposes and still assure recipients and inbox providers that the emails come from you. This can protect the sending reputation of your transactional emails from any negative recipient response to your marketing emails, and allows you to configure different domain settings such as open and click tracking for each subdomain.

## Domain features

When you add a domain, you can choose to:

* Enable [open and click tracking](/docs/dashboard/domains/tracking) for your emails.
* Configure [Enforced Transport Layer Security (TLS)](/docs/dashboard/domains/tls) to ensure that you only send encrypted emails.
* Set a custom subdomain for the [Return-Path address](/docs/dashboard/domains/custom-return-path).
* Choose which [geographical region](/docs/dashboard/domains/regions) to send emails from to reach your recipients sooner.

After your domain is verified, you can:

* Send and receive emails [using any email address at your domain](/docs/knowledge-base/how-do-I-create-an-email-address-or-sender-in-resend#sender-email-addresses-in-resend) without any extra configuration.
* Implement [DMARC](/docs/dashboard/domains/dmarc) and [BIMI](/docs/dashboard/domains/bimi) to build trust and improve inbox placement.

## Subdomains

We recommend sending your emails from one or more subdomains (e.g., `updates.example.com`) instead of your root domain to isolate your sending reputation and to clearly communicate your intent to your recipients.

> [!NOTE]
>
> If you're [moving email from another provider](#moving-from-another-provider)
> that already sends from an address with an established reputation, keep that
> address instead.

You must [add each subdomain](/docs/add-a-domain) individually, and they will be displayed in the [**Domains** Dashboard page](https://resend.com/domains) as separate entries where you can manage and configure them independently.

There are several benefits to sending from a subdomain:

* **Sender intent:** clearly communicate your intent to your recipients, increasing trust through transparency.
* **Reputation control:** Using separate subdomains can help segment sending reputation.
* **Configuration settings**: [Enabling open and click tracking](/docs/dashboard/domains/tracking) for your marketing emails, while keeping it disabled for your important transactional emails such as password resets.

Subdomains of your main domain also help reinforce your brand identity and build trust with inbox providers.

Domains that look like your main brand but aren’t actually your main brand (e.g., `example-alerts.com` instead of `alerts.example.com`) can appear suspicious to spam filters and confusing to your recipients. Inbox providers may flag them as phishing or spoofing attempts, and your users are more likely to ignore, delete, or even report the emails as spam.

### Moving from another provider

If you already send emails from an address with an established reputation, keep sending from that address when you switch to Resend to preserve your reputation history. Follow the [existing domain warm up plan](/docs/knowledge-base/warming-up#existing-domain) to avoid any spikes in email volume that might be concerning to inbox service providers.

If you have only sent a few emails, or you send irregularly, your domain has little history to lose if you start sending from a new subdomain in Resend, such as `news.example.com`. Follow the [new domain warm up plan](/docs/knowledge-base/warming-up#new-domain) to maximize your deliverability right from the start.

If you keep using an established email address for your marketing emails, add and warm up a new subdomain for your transactional emails, such as `auth.example.com`. This keeps your existing sender reputation for marketing emails, which are more likely to benefit from your history than transactional emails.

## Domain management

You can view and manage your domains from the [Domains Dashboard page](https://resend.com/domains). The Dashboard allows all members of your team to create, verify, retrieve, update, and delete your domains.

You can also manage your sending and receiving domains using the [API](/docs/api-reference/domains/create-domain), the [CLI](/docs/cli#domains), or the [MCP server](/docs/mcp-server).

Learn more about [managing your domains](/docs/dashboard/domains/manage-domains).

## Related Guides

See how to use Resend's verified domain features.

> [card] [Manage domains](/docs/dashboard/domains/manage-domains)

> [card] [Implement DMARC](/docs/dashboard/domains/dmarc)

> [card] [Enable Tracking](/docs/dashboard/domains/tracking)

> [card] [Enforced TLS](/docs/dashboard/domains/tls)

> [card] [Custom return path](/docs/dashboard/domains/custom-return-path)

> [card] [Choose region](/docs/dashboard/domains/regions)

> [card] [Claim a domain](/docs/dashboard/domains/claim)

> [card] [DNS provider guides](/docs/knowledge-base/introduction#dns-guides)


# Managing Domains
Source: https://resend.com/docs/dashboard/domains/manage-domains

Learn how to view, update, and delete your verified domains in Resend.

## Domain management

You can view and manage your domains from the [Domains Dashboard page](https://resend.com/domains). You can also manage your sending and receiving domains using the [API](/docs/api-reference/domains/create-domain), the [CLI](/docs/cli#domains), or the [MCP server](/docs/mcp-server).

All members of your team can create, verify, retrieve, update, and delete your domains.

> [!NOTE]
>
> The number of domains your team can add is set by your plan, listed on the
> [pricing page](https://resend.com/pricing). Paid transactional plans can raise
> the limit with the domains add-on. See [How to add more
> domains](/docs/knowledge-base/how-to-add-more-domains).

## View domain details

The [Domains Dashboard page](https://resend.com/domains) shows information about each domain's name, its verification status, and history. You can also filter your domains list by [status](#understand-a-domain-status) and [region](/docs/dashboard/domains/regions) and perform bulk actions on multiple domains, such as [deleting domains](#delete-a-domain).

You can also [retrieve a single domain](/docs/api-reference/domains/get-domain) or [list all domains](/docs/api-reference/domains/list-domains) via the API or SDKs, or use [CLI commands to view your domains](/docs/cli#domains).

## Understand a domain status

Domains can have different statuses, including:

* `not_started`: You've added a domain to Resend, but you haven't clicked on `Verify DNS Records` yet.
* `pending`: Resend is still trying to verify the domain.
* `verified`: Your domain is successfully verified for sending in Resend.
* `partially_verified`: There are two cases in which you'll see a domain being partially verified. One case is when only one capability (send or receive) is verified while the other is still pending verification. The second case is when you are shown two CNAME records for sending, but only one of them is verified while the other is still pending verification, which means you can send normally, but don't have a fallback server in case one of the sending servers is down.
* `partially_failed`: The domain is verified but one of the features (send or receive) is not verified.
* `failed`: Resend was unable to detect the DNS records within 72 hours.
* `temporary_failure`: For a previously verified domain, Resend will periodically check for the DNS record required for verification. If at some point, Resend is unable to detect the record, the status would change to "Temporary Failure". Resend will recheck for the DNS record for 72 hours, and if it's unable to detect the record, the domain status would change to "Failure". If it's able to detect the record, the domain status would change to "Verified".

## View DNS records

For each domain you have added, you can view the [DKIM](#what-are-dkim-records) and [SPF](#what-are-spf-records) configurations generated by Resend, as well as [DMARC protocol parameters](/docs/dashboard/domains/dmarc) under the **Records** tab.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=feb6b86344d63199055cdaa7b15735fa)

> [!NOTE]
>
> Need specific help adding your records to a DNS provider? View our [DNS
> Guides](/docs/knowledge-base).

## Update domain configuration

When viewing an individual domain, you can update its configuration options for [TLS](/docs/dashboard/domains/tls) and [tracking](/docs/dashboard/domains/tracking). You can also [delete your domain](#delete-a-domain) if you no longer want it associated with your Resend team.

## Delete a domain

Delete one or more domains by selecting them in your Domains Dashboard page and use the bulk action bar to delete all selected domains.

You can also delete a domain with the [Domains API](/docs/api-reference/domains/delete-domain), or with a [domains CLI command](/docs/cli#domains).

## Transfer a domain between teams

A domain can only be active on one Resend team at a time. For example, if someone else has already verified your domain in their own team, you will not be able to add it to yours.

To transfer a domain between teams you or your team members own, you must [delete the domain](#delete-a-domain) from the team where it is verified and [add it as a new domain](/docs/add-a-domain) while logged in to the desired team.

If you are unable to add a domain you own because it is already associated with a Resend team that you do not control, you can [claim the domain](/docs/dashboard/domains/claim).

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

> [!NOTE]
>
> Currently, exports are limited to admin users of your team.

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

> [!NOTE]
>
> All exports your team creates are listed in the
> [Exports](https://resend.com/exports) page under **Settings** > **Team** >
> **Exports**. Select any export to view its details page. All members of your
> team can view your exports, but only admins can download the data.

## What are SPF records

Sender Policy Framework (SPF) is an email authentication standard that includes all the IP addresses authorized to send email on behalf of your domain.

The SPF configuration is made of a TXT DNS record that lists the IP addresses approved by the domain owner. Resend also generates an MX record that allows the recipient to send bounce and complaint feedback to your domain.

> [!TIP]
>
> SPF-related records are not always shown as TXT and MX records. For domains
> created after August 2026, Resend may generate CNAME records instead, which
> point to hosts that carry all the necessary information for SPF-related
> verification. Therefore, make sure to always add the exact records shown in
> your domain's **Records** tab within the Resend dashboard.

![SPF Records](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=630f500feba7768e05a69340e8a6dae5)

## What are DKIM records

DomainKeys Identified Mail (DKIM) is an email security standard designed to make sure that an email that claims to come from a specific domain was authorized by the owner of that domain.

The DKIM configuration is stored as a TXT DNS record that contains a public key used to verify the authenticity of the email.

![DKIM Records](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)


# Choosing a Region
Source: https://resend.com/docs/dashboard/domains/regions

Resend offers sending from multiple regions

Resend users have the option to send transactional and marketing emails from four different regions:

* North Virginia (us-east-1)
* Ireland (eu-west-1)
* São Paulo (sa-east-1)
* Tokyo (ap-northeast-1)

No matter where your users are, you can ensure that they receive your emails in a timely and efficient manner. You can visualize the different regions in the Resend dashboard:

![Multi Region Domains](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/multi-region-1.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=0572cd0780bdcfc50ad558666dd8d7a5)

## Data Residency

Region selection controls where your emails are **routed and sent from**. It does not control where customer data is stored.

All account data, including email metadata, logs, and API records, is stored in the United States regardless of the sending region you select. Choosing `eu-west-1` means your emails are dispatched from Ireland, but your Resend account data still resides in the US.

If your organization has strict data residency requirements, review the [Resend Subprocessors list](https://resend.com/legal/subprocessors) and [Privacy Policy](https://resend.com/legal/privacy-policy) for details on data handling.

## Benefits of choosing a region

Especially for transactional emails like magic links, password resets, and welcome messages, users expect to receive them right away. If they don't, they might not be able to access your service right away, which is a missed opportunity for your organization.

Here are some of the other benefits of using our multi-region email sending feature:

1. **Faster delivery:** By sending emails from the region closest to your user, you can reduce latency and ensure a faster time-to-inbox. This can be the difference between people using/buying your product or not.
2. **Easier account management:** Instead of having to maintain different accounts for each region, you get multi-region support within the same account. That way, you aren't juggling different login credentials.
3. **Increased resilience:** In case of disruption in one region, our multi-region feature enables you to send emails from a backup domain in a separate region, guaranteeing maximum uptime.

## Get Started

To start using our multi-region email sending feature, go to **[Domains](https://resend.com/domains)**, then select the option to add a new domain.

Finally, select the region you want to send your emails.

## How to set up multi-region for the same domain

For advanced needs, you can set up multiple regions for the same domain. We recommend setting a unique subdomain for each region (e.g., us.example.com, eu.example.com). When sending transactional emails or marketing emails, choose the right domain for your users.

## Changing Domain Region

If you'd like to switch the region your domain is set to:

1. Delete your current domain in the [Domain's page](https://resend.com/domains).
2. Add the same domain again, selecting the new region.
3. Update your DNS records to point to the new domain.

For more help, please reach out to [Support](https://resend.com/help) for assistance.


# Configure Transport Layer Security (TLS)
Source: https://resend.com/docs/dashboard/domains/tls

Learn how to configure TLS for your verified domain in Resend.

## Configure Enforced Transport Layer Security (TLS)

Resend supports TLS 1.2, TLS 1.1 and TLS 1.0 for TLS connections, but only requires TLS for sending when Enforced TLS is configured.

By default, Resend will attempt to make a secure connection, but will fall back to sending messages unencrypted when the receiving server does not support TLS. This is known as Opportunistic TLS.

You can instead configure Enforced TLS in the Resend Dashboard under the **Configuration** tab or with the [Domains API](/docs/api-reference/domains/create-domain) or with [a domains CLI command](/docs/cli#domains). This means that if the receiving server does not support TLS, your email will not be sent.

Learn more about [Opportunistic TLS vs Enforced TLS](/docs/knowledge-base/whats-the-difference-between-opportunistic-tls-vs-enforced-tls).


# Open and Click Tracking
Source: https://resend.com/docs/dashboard/domains/tracking

Track open and click rates of your emails.

Open and click tracking is disabled by default for all domains. These settings apply to all emails sent from that domain.

We suggest only tracking open rates for the domain (or subdomain) used to send your [Broadcasts](/docs/dashboard/broadcasts/introduction) to ensure that inbox providers do not mistakenly identify your [transactional emails](/docs/dashboard/emails/introduction) as marketing emails.

> [!NOTE]
>
> Learn more about why it is better to [send emails from a
> subdomain](/docs/dashboard/domains/introduction#subdomains) than from your root
> domain.

You can enable tracking in the Resend Dashboard under the **Configuration** tab or programmatically when you create a new domain or update an existing domain.

Once verified, all tracked links in your emails will use your tracking subdomain (e.g., `links.emails.example.com`).

## Enable tracking using the Dashboard

**1. Go to the [**Domains** Dashboard page](https://resend.com/domains) and click on the domain you want to configure.**

**2. In the **Configuration** tab, click **Configure** under **Enable tracking metrics**.**

![Open and Click Tracking](https://mintcdn.com/resend/8slja5cHAobSwGo7/images/dashboard-domains-custom-tracking-domains.png?fit=max\&auto=format\&n=8slja5cHAobSwGo7\&q=85\&s=b94c649f1c22c899c144cd73ab5a8e73)

**3. Provide a name for your tracking subdomain, enable open and/or click tracking, and click **+Add domain**.**

![Verify Custom Tracking Subdomain](https://mintcdn.com/resend/aVe4W1upaT_ALaEY/images/dashboard-custom-tracking-domain-verify.png?fit=max\&auto=format\&n=aVe4W1upaT_ALaEY\&q=85\&s=aac30239e34f1fbf89bb9e41ba5540e8)

**4. Add the CNAME record to your DNS settings (e.g. Cloudflare, GoDaddy, etc.) to verify your tracking subdomain.**

![Add Custom Tracking Subdomain](https://mintcdn.com/resend/aVe4W1upaT_ALaEY/images/dashboard-domains-custom-tracking-domains-add.png?fit=max\&auto=format\&n=aVe4W1upaT_ALaEY\&q=85\&s=118b4d5f8269265c5eed074a52a2c9e5)

> [!NOTE]
>
> If we detect CAA records on your domain, we will show an additional CAA record
> that needs to be created. This ensures that we can issue a TLS certificate for
> your tracking subdomain.

**5. Click **I've added the records** to verify the domain.**

Once verified, all tracked links in your emails will use your custom tracking subdomain.

## Enable tracking via the API

**1. Provide the tracking subdomain**

When [adding a new domain](/docs/add-a-domain) to Resend, add tracking by passing the `tracking_subdomain` field along with `click_tracking` and/or `open_tracking`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.create({
  name: 'example.com',
  openTracking: true,
  clickTracking: true,
  trackingSubdomain: 'links',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->create([
  'name' => 'example.com',
  'open_tracking' => true,
  'click_tracking' => true,
  'tracking_subdomain' => 'links',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Domains.CreateParams = {
  "name": "example.com",
  "open_tracking": True,
  "click_tracking": True,
  "tracking_subdomain": "links",
}

resend.Domains.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  name: "example.com",
  open_tracking: true,
  click_tracking: true,
  tracking_subdomain: "links",
}
Resend::Domains.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateDomainRequest{
    Name:              "example.com",
    OpenTracking:      resend.Bool(true),
    ClickTracking:     resend.Bool(true),
    TrackingSubdomain: "links",
  }

  client.Domains.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateDomainOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _domain = resend
    .domains
    .create(
      CreateDomainOptions::new("example.com")
        .with_open_tracking(true)
        .with_click_tracking(true)
        .with_tracking_subdomain("links"),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.services.domains.model.CreateDomainOptions;

Resend resend = new Resend("re_xxxxxxxxx");

CreateDomainOptions params = CreateDomainOptions.builder()
        .name("example.com")
        .openTracking(true)
        .clickTracking(true)
        .trackingSubdomain("links")
        .build();

resend.domains().create(params);
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

var resp = await resend.DomainAddAsync( new DomainAddData()
{
    DomainName = "example.com",
    OpenTracking = true,
    ClickTracking = true,
    TrackingSubdomain = "links",
} );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/domains' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json' \
    -d $'{
  "name": "example.com",
  "open_tracking": true,
  "click_tracking": true,
  "tracking_subdomain": "links"
}'
```

If you already have a verified domain, call the `update` endpoint to add a tracking subdomain and enable tracking.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.update({
  id: 'd91cd9bd-1176-453e-8fc1-35364d380206',
  openTracking: true,
  clickTracking: true,
  trackingSubdomain: 'links',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->update(
  'd91cd9bd-1176-453e-8fc1-35364d380206',
  [
    'open_tracking' => true,
    'click_tracking' => true,
    'tracking_subdomain' => 'links',
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Domains.UpdateParams = {
  "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
  "open_tracking": True,
  "click_tracking": True,
  "tracking_subdomain": "links",
}

resend.Domains.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Domains.update({
  id: "d91cd9bd-1176-453e-8fc1-35364d380206",
  open_tracking: true,
  click_tracking: true,
  tracking_subdomain: "links",
})
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.UpdateDomainRequest{
    OpenTracking:      true,
    ClickTracking:     true,
    TrackingSubdomain: "links",
  }

  client.Domains.Update("d91cd9bd-1176-453e-8fc1-35364d380206", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::DomainChanges, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let changes = DomainChanges::new()
    .with_open_tracking(true)
    .with_click_tracking(true)
    .with_tracking_subdomain("links");

  let _domain = resend
    .domains
    .update("d91cd9bd-1176-453e-8fc1-35364d380206", changes)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.services.domains.model.UpdateDomainOptions;

Resend resend = new Resend("re_xxxxxxxxx");

UpdateDomainOptions params = UpdateDomainOptions.builder()
        .id("d91cd9bd-1176-453e-8fc1-35364d380206")
        .openTracking(true)
        .clickTracking(true)
        .trackingSubdomain("links")
        .build();

resend.domains().update(params);
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

await resend.DomainUpdateAsync(
    new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ),
    new DomainUpdateData()
    {
        TrackOpen = true,
        TrackClicks = true,
        TrackingSubdomain = "links",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json' \
    -d $'{
  "open_tracking": true,
  "click_tracking": true,
  "tracking_subdomain": "links"
}'
```

**2. Add the CNAME record to your DNS settings (e.g. Cloudflare, GoDaddy, etc.) to verify your tracking subdomain.**

![Add Custom Tracking Subdomain](https://mintcdn.com/resend/aVe4W1upaT_ALaEY/images/dashboard-domains-custom-tracking-domains-add.png?fit=max\&auto=format\&n=aVe4W1upaT_ALaEY\&q=85\&s=118b4d5f8269265c5eed074a52a2c9e5)

> [!NOTE]
>
> If we detect CAA records on your domain, we will show an additional CAA record
> that needs to be created. This ensures that we can issue a TLS certificate for
> your tracking subdomain.

Whether creating or updating a domain, the API will return the required DNS records that need to be added to your domain provider's DNS settings. Note the `Tracking` record.

```json {15-22} API Response Example theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
  "name": "example.com",
  "created_at": "2026-03-28 17:12:02.059593+00",
  "status": "not_started",
  "open_tracking": true,
  "click_tracking": true,
  "tracking_subdomain": "links",
  "capabilities": {
    "sending": "enabled",
    "receiving": "disabled"
  },
  "records": [
    // ... other records ...
    {
      "record": "Tracking",
      "name": "links.example.com",
      "type": "CNAME",
      "value": "links1.resend-dns.com",
      "ttl": "Auto",
      "status": "not_started"
    }
  ],
  "region": "us-east-1"
}
```

> [!NOTE]
>
> If we detect CAA records on your domain, we will show an additional CAA record
> that needs to be created. This ensures that we can issue a TLS certificate for
> your tracking subdomain.

**3. Verify the domain**

Once you've added the required DNS record(s), call the `verify` endpoint to verify the domain.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.domains.verify(
  'd91cd9bd-1176-453e-8fc1-35364d380206',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->domains->verify('d91cd9bd-1176-453e-8fc1-35364d380206');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Domains.verify(domain_id="d91cd9bd-1176-453e-8fc1-35364d380206")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Domains.verify("d91cd9bd-1176-453e-8fc1-35364d380206")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
  client := resend.NewClient("re_xxxxxxxxx")

  client.Domains.Verify("d91cd9bd-1176-453e-8fc1-35364d380206")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  resend
    .domains
    .verify("d91cd9bd-1176-453e-8fc1-35364d380206")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.services.domains.model.VerifyDomainResponse;

Resend resend = new Resend("re_xxxxxxxxx");

VerifyDomainResponse verified = resend.domains().verify("d91cd9bd-1176-453e-8fc1-35364d380206");
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" );

await resend.DomainVerifyAsync( new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206/verify' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json'
```

> [!NOTE]
>
> Tracking is active only when both of these conditions are met:
>
> <ol>
>   <li>
>     The `open_tracking` or `click_tracking` setting is enabled for the domain.
>   </li>
>
>   <li>
>     A tracking subdomain is configured (e.g., `links.example.com`) and
>     successfully verified.
>   </li>
> </ol>

All tracked links in your emails will use your tracking subdomain.

View the [API reference](/docs/api-reference/domains/create-domain) for more details.

## How Open Tracking Works

A 1x1 pixel transparent GIF image is inserted in each email and includes a unique reference to this image file. When
the image is downloaded, Resend can tell exactly which message was opened and by whom.

## How Click Tracking Works

To track clicks, Resend modifies each link in the body of the HTML email to point to your tracking subdomain.

When recipients clicks a link, the request is redirected to your tracking subdomain, their click event is recorded, and they are redirected to the original URL.

## Why open rates are not accurate

Open tracking is generally not accurate because each inbox handles incoming email differently.

**Clipped messages in Gmail** happen when you send a message over 102KB. A message over this size won’t be counted as an open unless the recipient views the entire message. Resend’s Deliverability Insights on the email will note if a message exceeds this threshold.

**Some inboxes do not download images by default** or block/cache assets with a corporate firewall. This approach can prevent the open event from being tracked.

**Other inboxes open the email prior to delivering** to scan for malware or to [protect user privacy](https://www.apple.com/newsroom/2021/06/apple-advances-its-privacy-leadership-with-ios-15-ipados-15-macos-monterey-and-watchos-8/). This approach can trigger an open event without the recipient reading your email.

**Emails sent with only a plain text version** will not include open tracking at all. Since open tracking relies on a 1x1 pixel image, plain text emails cannot trigger open events. Only emails with an HTML version can be tracked for opens.

Because of this, open tracking is **not a statistically accurate way** of detecting if your users are engaging with your content.

## How open tracking impacts inbox placement

Though open tracking does not impact whether your email is delivered, it most likely will impact your inbox placement. Trackers are generally **used by marketers and even spammers**. Because of this, inbox providers will often use open tracking as a signal that your email is promotional, or even spam, and categorize accordingly.

**We recommend disabling open rates for transactional email**, to maximize inbox placement.

## Alternatives to open tracking

Instead of relying on open rates, there are a few other ways to still understand your sending.

1. **Track Clicks:** Monitoring the link clicks is an even more granular way to know how a recipient engaged with your email. By knowing if they clicked, you also know that they read parts of your email and took action.
2. **Track Outside the Inbox:** Often emails are sent as a means to an end. Maybe it's to increase page visits of an announcement or convert free users to paid. Tracking your sending by metrics outside of the inbox can be a great way to understand the true impact of your sending.

## Troubleshooting

### Multiple tracking CNAME records

When you change your tracking subdomain, you may see two CNAME records in the DNS Records table: one active and one inactive (shown dimmed). The inactive record is kept intentionally to avoid breaking links in emails that were already sent using the previous subdomain. You do not need to remove it.

### Changing the Tracking Subdomain

Because tracking subdomains are used in email links, they're handled differently than other records.

* **Not removable**: After your tracking subdomain has been created, it can only be changed, never removed. This behavior preserves any
  email links that may already be sent with the current tracking subdomain. For this reason, do **not remove old tracking DNS records**. (All previously used records remain active and are included in the response.)
* **Requires verification**: After changing the tracking subdomain, a new DNS record must be verified. Until then, the previous value is used.

### Removing a Domain with a Tracking Subdomain

If you remove a domain with a configured tracking subdomain, the Resend provisioned proxy will also be removed, breaking
any existing email links that use that subdomain.

To keep links working, set up your own proxy pointing to Resend’s tracking DNS records before removing the domain.

### Unsupported Domains

Custom tracking subdomains require us to issue a TLS certificate. Some domains under regional restrictions are not
supported by our certificate provider and cannot use custom tracking subdomains. Learn more in the [certificate provider
docs](https://knowledge.digicert.com/solution/embargoed-countries-and-regions).


# Add an unsubscribe link to transactional emails
Source: https://resend.com/docs/dashboard/emails/add-unsubscribe-to-transactional-emails

Learn how to give email recipients the ability to unsubscribe without searching for the unsubscribe link.

> [!NOTE]
>
> For contact and unsubscribe management workflows, see the [Contacts
> overview](/docs/dashboard/contacts/introduction), where Broadcasts are built for
> keeping track of topics, segments, and unsubscribe preferences.

Resend doesn't manage contact lists for transactional emails.

If you manage your own list, you can add the `List-Unsubscribe: https://example.com/unsubscribe` header when sending emails using the Resend API.

As of February 2024, your bulk messages must include a URL version in your list-unsubscribe header, `List-Unsubscribe-Post: List-Unsubscribe=One-Click`, and to allow for a `POST` request from the same URL. This follows [RFC 8058](https://datatracker.ietf.org/doc/html/rfc8058) (Signaling One-Click Functionality for List Email Headers).

When receiving a `POST`, return a blank page with `200 (OK)` or `202 (Accepted)`, and show the regular unsubscribe page with the `GET` method. Ensure that users stop receiving email within 48 hours of this request.

This header allows email clients to offer a one-click "Unsubscribe" option in their UI, enhancing user experience and decreasing spam complaints. Gmail and Yahoo require RFC 8058 compliance for bulk senders (those sending more than 5,000 messages per day to their domains).

You can read more about this requirement in our [Bulk Sending Requirements blog post.](https://resend.com/blog/gmail-and-yahoo-bulk-sending-requirements-for-2024#one-click-unsubscribe)

```ts Node.js {11} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'hello world',
  text: 'it works!',
  headers: {
    'List-Unsubscribe': '<https://example.com/unsubscribe>',
  },
});
```


# Attachments
Source: https://resend.com/docs/dashboard/emails/attachments

Send emails with attachments.

There are two ways to send attachments:

1. [From a remote file](#send-attachments-from-a-remote-file)
2. [From a local file](#send-attachments-from-a-local-file)

> [!NOTE]
>
> We currently do not support sending attachments [when using our batch
> endpoint](/docs/api-reference/emails/send-batch-emails).

## Send attachments from a remote file

Include the `path` parameter to send attachments from a remote file. This parameter accepts a URL to the file you want to attach.

Define the file name that will be attached using the `filename` parameter.

```ts Node.js {12-13} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Receipt for your payment',
  html: '<p>Thanks for the payment</p>',
  attachments: [
    {
      path: 'https://resend.com/static/sample/invoice.pdf',
      filename: 'invoice.pdf',
    },
  ],
});
```

```php PHP {10-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'Receipt for your payment',
  'html' => '<p>Thanks for the payment</p>',
  'attachments' => [
    [
      'path' => 'https://resend.com/static/sample/invoice.pdf',
      'filename' => 'invoice.pdf'
    ]
  ]
]);
```

```python Python {6-7} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

attachment: resend.RemoteAttachment = {
  "path": "https://resend.com/static/sample/invoice.pdf",
  "filename": "invoice.pdf",
}

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Receipt for your payment",
  "html": "<p>Thanks for the payment</p>",
  "attachments": [attachment],
}

resend.Emails.send(params)
```

```rb Ruby {12-13} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Receipt for your payment",
  "html": "<p>Thanks for the payment</p>",
  "attachments": [
    {
      "path": "https://resend.com/static/sample/invoice.pdf",
      "filename": 'invoice.pdf',
    }
  ]
}

Resend::Emails.send(params)
```

```go Go {15-16} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  attachment := &resend.Attachment{
    Path:  "https://resend.com/static/sample/invoice.pdf",
    Filename: "invoice.pdf",
  }

  params := &resend.SendEmailRequest{
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Subject:     "Receipt for your payment",
      Html:        "<p>Thanks for the payment</p>",
      Attachments: []*resend.Attachment{attachment},
  }

  sent, err := client.Emails.SendWithContext(ctx, params)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Id)
}
```

```rust Rust {12-13} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Receipt for your payment";

  let path = "https://resend.com/static/sample/invoice.pdf";
  let filename = "invoice.pdf";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>Thanks for the payment</p>")
    .with_attachment(CreateAttachment::from_path(path).with_filename(filename));

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {12-13} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.Attachment;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Attachment att = Attachment.builder()
                .path("https://resend.com/static/sample/invoice.pdf")
                .fileName("invoice.pdf")
                .build();

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("Receipt for your payment")
                .html("<p>Thanks for the payment</p>")
                .attachments(att)
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {14-18} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Collections.Generic;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var message = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "Receipt for your payment",
    HtmlBody = "<p>Thanks for the payment</p>",
};

message.Attachments = new List<EmailAttachment>();
message.Attachments.Add( new EmailAttachment() {
  Filename = "invoice.pdf",
  Path = "https://resend.com/static/sample/invoice.pdf",
} );

var resp = await resend.EmailSendAsync( message );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {11-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Receipt for your payment",
  "html": "<p>Thanks for the payment</p>",
  "attachments": [
    {
      "path": "https://resend.com/static/sample/invoice.pdf",
      "filename": "invoice.pdf"
    }
  ]
}'
```

## Send attachments from a local file

Include the `content` parameter to send attachments from a local file. This parameter accepts the Base64 encoded content of the file you want to attach. In the Node.js SDK, you can also pass a buffer directly, and the SDK converts it to Base64 for you.

Define the file name that will be attached using the `filename` parameter.

```ts Node.js {16-17} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import fs from 'fs';

const resend = new Resend('re_xxxxxxxxx');

const filepath = `${__dirname}/static/invoice.pdf`;
const attachment = fs.readFileSync(filepath);

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Receipt for your payment',
  text: '<p>Thanks for the payment</p>',
  attachments: [
    {
      content: attachment,
      filename: 'invoice.pdf',
    },
  ],
});
```

```php PHP {12-13} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$attachment = base64_encode(file_get_contents(__DIR__ . '/static/invoice.pdf'));

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'Receipt for your payment',
  'html' => '<p>Thanks for the payment</p>',
  'attachments' => [
    [
      'filename' => 'invoice.pdf',
      'content' => $attachment
    ]
  ]
]);
```

```python Python {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
import os
import resend

resend.api_key = "re_xxxxxxxxx"

f: bytes = open(
  os.path.join(os.path.dirname(__file__), "../static/invoice.pdf"), "rb"
).read()

attachment: resend.Attachment = {"content": list(f), "filename": "invoice.pdf"}

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Receipt for your payment",
  "html": "<p>Thanks for the payment</p>",
  "attachments": [attachment],
}

resend.Emails.send(params)
```

```rb Ruby {14-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

file = IO.read("invoice.pdf")

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Receipt for your payment",
  "html": "<p>Thanks for the payment</p>",
  "attachments": [
    {
      "content": file.bytes,
      "filename": 'invoice.pdf',
    }
  ]
}

Resend::Emails.send(params)
```

```go Go {22-23} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"
	"os"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  pwd, _ := os.Getwd()
  f, err := os.ReadFile(pwd + "/static/invoice.pdf")
  if err != nil {
    panic(err)
  }

  attachment := &resend.Attachment{
    Content:  f,
    Filename: "invoice.pdf",
  }

  params := &resend.SendEmailRequest{
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Subject:     "Receipt for your payment",
      Html:        "<p>Thanks for the payment</p>",
      Attachments: []*resend.Attachment{attachment},
  }

  sent, err := client.Emails.SendWithContext(ctx, params)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Id)
}
```

```rust Rust {22} theme={"theme":{"light":"github-light","dark":"vesper"}}
use std::fs::File;
use std::io::Read;

use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Receipt for your payment";

  let filename = "invoice.pdf";
  let mut f = File::open(filename).unwrap();
  let mut invoice = Vec::new();
  f.read_to_end(&mut invoice).unwrap();

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>Thanks for the payment</p>")
    .with_attachment(CreateAttachment::from_content(invoice).with_filename(filename));

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {12-13} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.Attachment;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Attachment att = Attachment.builder()
                .fileName("invoice.pdf")
                .content("invoiceBuffer")
                .build();

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("Receipt for your payment")
                .html("<p>Thanks for the payment</p>")
                .attachments(att)
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {15-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Collections.Generic;
using System.IO;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var message = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "Receipt for your payment",
    HtmlBody = "<p>Thanks for the payment</p>",
};

message.Attachments = new List<EmailAttachment>();
message.Attachments.Add( new EmailAttachment() {
  Filename = "invoice.pdf",
  Content = await File.ReadAllBytesAsync( "invoice.pdf" ),
} );

var resp = await resend.EmailSendAsync( message );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {11-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Receipt for your payment",
  "html": "<p>Thanks for the payment</p>",
  "attachments": [
    {
      "content": "UmVzZW5kIGF0dGFjaG1lbnQgZXhhbXBsZS4gTmljZSBqb2Igc2VuZGluZyB0aGUgZW1haWwh%",
      "filename": "invoice.txt"
    }
  ]
}'
```

```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Receipt for your payment" \
  --html "<p>Thanks for the payment</p>" \
  --attachment ./static/invoice.pdf
```

## Embed Images using CID

You can optionally embed an image in the HTML body of the email. Both remote and local attachments are supported. All attachment requirements, options, and limitations apply to embedded inline images as well.

Embedding images requires two steps:

**1. Add the CID in the email HTML.**

Use the prefix `cid:` to reference the ID in the `src` attribute of an image tag in the HTML body of the email.

```html theme={"theme":{"light":"github-light","dark":"vesper"}}
<img src="cid:logo-image" />
```

**2. Reference the CID in the attachment**

The content id is an arbitrary string set by you, and must be less than 128 characters.

```ts Node.js {9, 14} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Thank you for contacting us',
  html: '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
  attachments: [
    {
      path: 'https://resend.com/static/sample/logo.png',
      filename: 'logo.png',
      contentId: 'logo-image',
    },
  ],
});
```

```php PHP {7,12} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'Thank you for contacting us',
  'html' => '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
  'attachments' => [
    [
      'path' => 'https://resend.com/static/sample/logo.png',
      'filename' => 'logo.png',
      'content_id' => 'logo-image',
    ]
  ]
]);
```

```python Python {8,15} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

attachment: resend.RemoteAttachment = {
  "path": "https://resend.com/static/sample/logo.png",
  "filename": "logo.png",
  "content_id": "logo-image",
}

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Thank you for contacting us",
  "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  "attachments": [attachment],
}

resend.Emails.send(params)
```

```rb Ruby {9, 14} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Thank you for contacting us",
  "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  "attachments": [
    {
      "path": "https://resend.com/static/sample/logo.png",
      "filename": 'logo.png',
      "content_id": "logo-image",
    }
  ]
}

Resend::Emails.send(params)
```

```go Go {17, 24} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  attachment := &resend.Attachment{
    Path:  "https://resend.com/static/sample/logo.png",
    Filename: "logo.png",
    ContentId: "logo-image",
  }

  params := &resend.SendEmailRequest{
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Subject:     "Thank you for contacting us",
      Html:        "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
      Attachments: []*resend.Attachment{attachment},
  }

  sent, err := client.Emails.SendWithContext(ctx, params)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Id)
}
```

```rust Rust {14, 17} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Thank you for contacting us";

  let path = "https://resend.com/static/sample/logo.png";
  let filename = "logo.png";
  let content_id = "logo-image";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
    .with_attachment(
      CreateAttachment::from_path(path)
        .with_filename(filename)
        .with_content_id(content_id),
    );

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {14, 21} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.Attachment;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Attachment att = Attachment.builder()
                .path("https://resend.com/static/sample/logo.png")
                .fileName("logo.png")
                .contentId("logo-image")
                .build();

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("Thank you for contacting us")
                .html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
                .attachments(att)
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {11, 18} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Collections.Generic;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var message = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "Thank you for contacting us",
    HtmlBody = "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
};

message.Attachments = new List<EmailAttachment>();
message.Attachments.Add( new EmailAttachment() {
  Filename = "logo.png",
  Path = "https://resend.com/static/sample/logo.png",
  ContentId = "logo-image",
} );

var resp = await resend.EmailSendAsync( message );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {8,13} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Thank you for contacting us",
  "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  "attachments": [
    {
      "path": "https://resend.com/static/sample/logo.png",
      "filename": "logo.png",
      "content_id": "logo-image"
    }
  ]
}'
```

Learn more about [embedding images](/docs/dashboard/emails/embed-inline-images).

## View and Download Attachments

You can view and download attachments from sent emails from the dashboard or programmatically through the [Attachments API](/docs/api-reference/emails/list-email-attachments).

### From the dashboard

1. Go to [Emails](https://resend.com/emails).
2. Navigate to any email you sent with an attachment.
3. Click on the attachment to download it locally.

Attachments include the filename and an icon to help you identify the type of attachment. Each attachment type has a unique icon:

* Image
* PDF
* Spreadsheet
* Default (for unknown types)

### From the API

Use [List Attachments](/docs/api-reference/emails/list-email-attachments) to fetch all attachments for a sent email, or [Retrieve Attachment](/docs/api-reference/emails/retrieve-email-attachment) to fetch a single one. Both endpoints return a signed `download_url` that you can use to download the content.

## Attachment Limitations

* Emails can be no larger than 40MB (including attachments after Base64 encoding).
* Not all file types are supported. See the list of [unsupported file types](/docs/knowledge-base/what-attachment-types-are-not-supported).
* Emails with attachments cannot be sent using our [batching endpoint](/docs/api-reference/emails/send-batch-emails).

## Examples

### Attachments

> [card] [Next.js (TypeScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/attachments)
>
> See the full source code.

> [card] [Next.js (JavaScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/attachments)
>
> See the full source code.

> [card] [PHP](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/attachments)
>
> See the full source code.

> [card] [Laravel](https://github.com/resend/resend-examples/tree/main/laravel-resend-examples)
>
> See the full source code.

> [card] [Python](https://github.com/resend/resend-examples/tree/main/python-resend-examples/examples)
>
> See the full source code.

> [card] [Ruby](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples)
>
> See the full source code.

### Inline Images (CID)

> [card] [Next.js (TypeScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/cid-attachments)
>
> See the full source code.

> [card] [Next.js (JavaScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/cid-attachments)
>
> See the full source code.

> [card] [PHP](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/attachments)
>
> See the full source code.

> [card] [Laravel](https://github.com/resend/resend-examples/tree/main/laravel-resend-examples)
>
> See the full source code.

> [card] [Python](https://github.com/resend/resend-examples/tree/main/python-resend-examples/examples)
>
> See the full source code.

> [card] [Ruby](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples)
>
> See the full source code.


# Batch Sending
Source: https://resend.com/docs/dashboard/emails/batch-sending

Send up to 100 emails in a single API call.

Batch sending allows you to send multiple emails at once (up to 100) instead of making individual API requests for each email.

## When to use batch sending

Use batch sending when you need to:

* Send multiple transactional emails (e.g., order confirmations and notifications)
* Trigger emails to different recipients with unique content
* Reduce the number of API calls to improve performance

> [!NOTE]
>
> For marketing campaigns, [use our no-code editor,
> Broadcasts](/docs/dashboard/broadcasts/introduction), instead.

## Send batch emails

You can send up to 100 emails in a single API call using the batch endpoint. Each email in the batch can have different recipients, subjects, and content.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.batch.send([
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Welcome to Acme',
    html: '<p>Thanks for signing up!</p>',
  },
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Order Confirmation',
    html: '<p>Your order has been confirmed.</p>',
  },
]);

console.log(data);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->batch->send([
  [
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'Welcome to Acme',
    'html' => '<p>Thanks for signing up!</p>',
  ],
  [
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'Order Confirmation',
    'html' => '<p>Your order has been confirmed.</p>',
  ]
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend
from typing import List

resend.api_key = "re_xxxxxxxxx"

params: List[resend.Emails.SendParams] = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Welcome to Acme",
    "html": "<p>Thanks for signing up!</p>",
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Order Confirmation",
    "html": "<p>Your order has been confirmed.</p>",
  }
]

resend.Batch.send(params)
```

```rb Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = 're_xxxxxxxxx'

params = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Welcome to Acme",
    "html": "<p>Thanks for signing up!</p>",
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Order Confirmation",
    "html": "<p>Your order has been confirmed.</p>",
  }
]

Resend::Batch.send(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  var batchEmails = []*resend.SendEmailRequest{
    {
      From:    "Acme <onboarding@resend.dev>",
      To:      []string{"delivered@resend.dev"},
      Subject: "Welcome to Acme",
      Html:    "<p>Thanks for signing up!</p>",
    },
    {
      From:    "Acme <onboarding@resend.dev>",
      To:      []string{"delivered@resend.dev"},
      Subject: "Order Confirmation",
      Html:    "<p>Your order has been confirmed.</p>",
    },
  }

  sent, err := client.Batch.SendWithContext(ctx, batchEmails)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Data)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let emails = vec![
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["delivered@resend.dev"],
      "Welcome to Acme",
    )
    .with_html("<p>Thanks for signing up!</p>"),
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["delivered@resend.dev"],
      "Order Confirmation",
    )
    .with_html("<p>Your order has been confirmed.</p>"),
  ];

  let _emails = resend.batch.send(emails).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.batch.model.CreateBatchEmailsResponse;
import com.resend.services.emails.model.CreateEmailOptions;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions firstEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("delivered@resend.dev")
            .subject("Welcome to Acme")
            .html("<p>Thanks for signing up!</p>")
            .build();

        CreateEmailOptions secondEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("delivered@resend.dev")
            .subject("Order Confirmation")
            .html("<p>Your order has been confirmed.</p>")
            .build();

        CreateBatchEmailsResponse data = resend.batch().send(
            Arrays.asList(firstEmail, secondEmail)
        );
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create("re_xxxxxxxxx");

var mail1 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "Welcome to Acme",
    HtmlBody = "<p>Thanks for signing up!</p>",
};

var mail2 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "Order Confirmation",
    HtmlBody = "<p>Your order has been confirmed.</p>",
};

var resp = await resend.EmailBatchAsync([mail1, mail2]);
Console.WriteLine("Nr Emails={0}", resp.Content.Count);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails/batch' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'[
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Welcome to Acme",
    "html": "<p>Thanks for signing up!</p>"
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Order Confirmation",
    "html": "<p>Your order has been confirmed.</p>"
  }
]'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails batch --file ./path/to/emails.json
```

## Response format

The batch endpoint returns an array of email IDs for successfully created emails.
When the request succeeds, each entry in `data` corresponds to the email at the same index in the batch payload (0-based). The first email in your request will be the first entry in `data`, and so on.

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "data": [
    {
      "id": "ae2014de-c168-4c61-8267-70d2662a1ce1"
    },
    {
      "id": "faccb7a5-8a28-4e9a-ac64-8da1cc3bc1cb"
    }
  ]
}
```

If the request fails, the response will include an `error` object with a `message` property. You can find more information about the error in the [Errors](/docs/api-reference/errors) section of the API Reference.

## Limitations

When using batch sending, keep in mind:

* Maximum of **100 emails** per batch request
* The `attachments` field is not supported yet
* Each email in the batch is processed independently
* The request will fail and return an error if any email in your payload is invalid (for example, required fields are missing or fields contain invalid data).

## View batch emails

All emails sent via the batch endpoint appear in the [Emails page](https://resend.com/emails) of your dashboard along with individually sent emails. Each email will have a `queued` status initially before being processed.

## API Reference

For complete API documentation, see the [Send Batch Emails API reference](/docs/api-reference/emails/send-batch-emails).


# Custom Headers
Source: https://resend.com/docs/dashboard/emails/custom-headers

Customize how emails are sent with your own headers.

Email headers are typically hidden from the end user but are crucial for deliverability. They include information about the sender, receiver, timestamp, and more.

Resend already includes all the necessary headers for you, but now you can also add your own custom headers.

This is a fairly advanced feature, but it can be useful for a few things:

* Prevent threading on Gmail with the **`X-Entity-Ref-ID`** header ([Example](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/prevent-threading))
* Include a shortcut for users to unsubscribe with the **`List-Unsubscribe`** header

Here's how you can add custom headers to your emails:

```ts Node.js {11} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'hello world',
  html: '<p>it works!</p>',
  headers: {
    'X-Entity-Ref-ID': 'xxx_xxxx',
  },
});
```

```php PHP {9} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'html' => '<p>it works!</p>',
  'headers' => [
    'X-Entity-Ref-ID' => 'xxx_xxxx',
  ]
]);
```

```python Python {11} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Emails.SendParams = {
  "from": "onboarding@resend.dev",
  "to": ["delivered@resend.dev"],
  "subject": "hi",
  "html": "<p>it works!</p>",
  "headers": {
    "X-Entity-Ref-ID": "xxx_xxxx"
  }
}

email = resend.Emails.send(params)
print(email)
```

```rb Ruby {11} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "headers": {
    "X-Entity-Ref-ID": "123"
  },
}

sent = Resend::Emails.send(params)
puts sent
```

```go Go {20} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.SendEmailRequest{
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Subject:     "hello world",
      Html:        "<p>it works!</p>",
      Headers:     map[string]string{
        "X-Entity-Ref-ID": "xxx_xxxx",
      },
  }

  sent, err := client.Emails.SendWithContext(ctx, params)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Id)
}
```

```rust Rust {14} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::{Attachment, CreateEmailBaseOptions, Tag};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "hello world";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>it works!</p>")
    .with_header("X-Entity-Ref-ID", "xxx_xxxx");

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {17} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;
import java.util.Map;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("hello world")
                .html("<p>it works!</p>")
                .headers(Map.of(
                    "X-Entity-Ref-ID", "xxx_xxxx"
                ))
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {12-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Collections.Generic;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var message = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
    Headers = new Dictionary<string, string>()
    {
        { "X-Entity-Ref-ID", "xxx_xxxx" },
    },
};

var resp = await resend.EmailSendAsync( message );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "headers": {
    "X-Entity-Ref-ID": "xxx_xxxx"
  }
}'
```

```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "hello world" \
  --html "<p>it works!</p>" \
  --headers "X-Entity-Ref-ID=xxx_xxxx"
```


# Deliverability Insights
Source: https://resend.com/docs/dashboard/emails/deliverability-insights

Improve your deliverability with tailored insights based on your sending.

When you view your email within Resend, there is a "Insights" option. When selected, this will run deliverability best practice checks on your email and recommend possible changes to improve deliverability.

![Deliverability Insights](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/deliverability-insights-1.jpg?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=78f3941a7a90d4546200c6cba6607270)

If a check passes, you'll get a nice green check. If a check fails, you'll get advice broken into two categories: Attention and Improvements.

## Attention Insights

Changes to your email that can improve deliverability.

![Attention Insights](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/deliverability-insights-2.jpg?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=158b0b42d45e7172f150a8818671a03e)

#### Ensure link URLs match sending domain

Ensure that the URLs in your email match the sending domain. Mismatched URLs can trigger spam filters.

For example, if your sending domain is `@widgets.com`, ensure links within the message point back to `https://widgets.com`.

#### Include valid DMARC record

DMARC is a TXT record published in the DNS that specifies how email receivers should handle messages from your domain that don't pass SPF or DKIM validation. [A valid DMARC record](/docs/dashboard/domains/dmarc) can help improve email deliverability.

Gmail and Yahoo have required bulk senders to have a DMARC record published since 2024. When [viewing your domain](https://resend.com/domains) in Resend, you'll see a suggested DMARC record if you’re unsure what to publish.

#### Include Plain Text Version

Including a plain text version of your email ensures that your message is accessible to all recipients, including those who have email clients that do not support HTML.

If you're using Resend's API, [plain text is passed via the `text` parameter](https://resend.com/docs/api-reference/emails/send-email).

This can also generate plain text using [React Email](https://react.email/docs/utilities/render#4-convert-to-plain-text).

#### Don't use "no-reply"

Indicating that this is a one-way communication decreases trust. Some email providers use engagement (email replies) when deciding how to filter your email. A valid email address allows you to communicate with your recipients if they have questions.

#### Keep email body size small

Gmail limits the size of each email message to 102 KB. Once that limit is reached, the remaining content is clipped and hidden behind a link to view the entire message. Keep your email body size small to avoid this issue.

This check will show the current size of your email.

#### Use full YouTube URLs

Gmail's spam filters are flagging emails containing shortened YouTube links (`youtu.be`) as potential phishing attempts. Use full YouTube URLs instead (`youtube.com/watch?v=...`).

For example, instead of using `https://youtu.be/abc123`, use `https://www.youtube.com/watch?v=abc123`.

## Improvement Insights

If you're diagnosing a deliverability issue, changing your email practices may help.

![Improvement Insights](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/deliverability-insights-3.jpg?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=64e4640b71c022a296f423ce4afdfbc8)

#### Use a Subdomain

Using a subdomain instead of the root domain helps segment your sending by purpose. This protects different types of sending from impacting the reputation of others and clearly shows the sending purpose.

#### Use Custom Subdomain for Click Tracking

You're using a shared tracking domain for click tracking. Shared tracking domains can hurt deliverability because spam filters may flag links rewritten through shared domains as suspicious. Configure a custom tracking subdomain to keep links on your own domain and improve deliverability.

Learn how to [configure a custom tracking subdomain](/docs/dashboard/domains/tracking).

#### Use Custom Subdomain for Open Tracking

You're using a shared tracking domain for open tracking. Spam filters are sensitive to tracking pixels served from shared domains, and may flag them as potential spam. Configure a custom tracking subdomain to serve tracking pixels from your own domain and improve deliverability.

Learn how to [configure a custom tracking subdomain](/docs/dashboard/domains/tracking).

> [!NOTE]
>
> Open rates are not always accurate. Learn more about [why open rates may not
> be accurate](/docs/knowledge-base/why-are-my-open-rates-not-accurate).


# Email Bounces
Source: https://resend.com/docs/dashboard/emails/email-bounces

Understanding and resolving delivery issues.

## Why emails bounce

A bounce happens when an email cannot be delivered to the person it was meant for, and is returned to the sender. It essentially "bounces" back to the person who sent it.

Some reasons include invalid email addresses, full mailboxes, and technical issues with email servers. Other causes are spam filters, message size restrictions, or blacklisting of the sender's email server.

## Bounce Types and Subtypes

When an email bounces, Resend receives a message from the recipient's mail server. The bounce message explains why the delivery failed so the sender can fix the issue.

There are three types of bounces:

1. `Permanent` - also known as "hard bounce,” where the recipient's mail server rejects the email and will never be delivered.
   * `General` - The recipient's email provider sent a hard bounce message.
   * `NoEmail` - It was not possible to retrieve the recipient email address from the bounce message.

2. `Transient` - also known as "soft bounce,” where the recipient's mail server rejects the email but it may be delivered in the future.
   * `General` - The recipient's email provider sent a general bounce message. You might be able to send a message to the same recipient in the future if the issue that caused the message to bounce is resolved.
   * `MailboxFull` - The recipient's email provider sent a bounce message because the recipient's inbox was full. You might be able to send to the same recipient in the future when the mailbox is no longer full.
   * `MessageTooLarge` - The recipient's email provider sent a bounce message because message you sent was too large. You might be able to send a message to the same recipient if you reduce the size of the message.
   * `ContentRejected` - The recipient's email provider sent a bounce message because the message you sent contains content that the provider doesn't allow. You might be able to send a message to the same recipient if you change the content of the message.
   * `AttachmentRejected` - The recipient's email provider sent a bounce message because the message contained an unacceptable attachment. For example, some email providers may reject messages with attachments of a certain file type, or messages with large attachments. You might be able to send a message to the same recipient if you remove or change the content of the attachment.

> [!TIP]
>
> Sometimes, inboxes use autoresponders to signal a bounce. A `transient` status
> could mean it's related to the autoresponder, and it's not a permanent issue.

3. `Undetermined` - where the recipient's email server bounced, but the bounce message didn't contain enough information for Resend to determine the underlying reason.
   * `Undetermined` - The recipient's email provider sent a bounce message. The bounce message didn't contain enough information for Resend to determine the reason for the bounce.

## Viewing Bounce Details in Resend

You can see the bounce details by clicking on the email, and hovering over the `Bounced` label.

![Email Bounce Notification](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/email-bounce-details-1.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=f0f99293137b8de4a9862b05cfd87d74)

Once you click **See Details**, the drawer will open on the right side of your screen with the bounce type, subtype, along with suggestions on how to proceed.

If the email is on the suppression list, you can click **Remove from Suppression List** to remove it.

![Email Bounce Drawer](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/email-suppression-list-2.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=baf9f0a40313b856be978b728fb1d01c)


# Email Suppressions
Source: https://resend.com/docs/dashboard/emails/email-suppressions

Managing your team Suppressions to protect your sending reputation.

When a mailbox provider hard-bounces a recipient, or someone marks your email as spam, continuing to send to that address harms your reputation.

Your suppressions list protects you by intentionally skipping sending to any addresses on your list.

## How addresses are suppressed

An address is added to Suppressions for one of three origins:

* `bounce`: the recipient's mail server [permanently rejected the email](/docs/dashboard/emails/email-bounces).
* `complaint`: the recipient marked your email as spam.
* `manual`: you add the recipient's address yourself.

Suppressions apply to your entire team. Any address added to the suppression list will be skipped across all your domains and subdomains when sending transactional or [Broadcast](/docs/dashboard/broadcasts/introduction) emails.

> [!TIP]
>
> Not all Inbox Service Providers return a `complained` event, most notably,
> Gmail/Google Workspace.

## Viewing Suppressions in Resend

You can see all Suppressions [in the Dashboard](https://resend.com/emails/suppressions) or list them [in the API](/docs/api-reference/suppressions/list-suppressions).

![Email Suppressions](https://mintcdn.com/resend/Nyu32IXsxRkmP92c/images/suppression-list-board.png?fit=max\&auto=format\&n=Nyu32IXsxRkmP92c\&q=85\&s=437d48fa3afbc7e4885ecaa139ce83bc)

You can also programmatically retrieve [a single Suppression](/docs/api-reference/suppressions/get-suppression) or [your entire suppression list](/docs/api-reference/suppressions/list-suppressions), which returns key data about the Suppression.

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "object": "suppression",
  "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  "email": "steve.wozniak@example.com",
  "origin": "bounce",
  "source_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
  "created_at": "2026-10-06 23:47:56.678+00"
}
```

`source_id` references the email id that triggered the suppression (is `null` for `manual` origin suppressions).

## Add emails to the Suppression List

In the Dashboard, go to the [Suppressions page](https://resend.com/emails/suppressions) and click **+ Add email address** to add an email address to the suppression list.

* **Add manually**: enter the email address you want to suppress.
* **Import CSV**: upload a file with a list of email addresses to suppress.

You can also [suppress individual emails](/docs/api-reference/suppressions/add-suppression) or [bulk suppress up to 100 at a time](/docs/api-reference/suppressions/add-batch-suppressions) using the API.

> [!NOTE]
>
> Remember that adding a Suppression will skip all sending to that recipient
> until it is removed from your team's suppression list.

## Remove emails from the Suppression List

Before removing an email address from the suppression list, ensure the reason for suppression has been addressed, or it will be automatically re-suppressed.

You can remove an email address from the suppression list in the Dashboard from the [Suppressions page](https://resend.com/emails/suppressions).

1. Search or filter for a suppression.
2. Click the **more options button**  and select **Remove email address**.

You can also [remove individual emails](/docs/api-reference/suppressions/remove-suppression) or [bulk remove up to 100 at a time](/docs/api-reference/suppressions/remove-batch-suppressions) using the API.

> [!WARNING]
>
> Removing an address from the suppression list does not guarantee delivery. If
> it bounces or is marked as spam again, it will be suppressed again
> automatically and damage your sender reputation.

## Webhook suppression notifications

For maximum visibility, track suppressions using webhook notifications.

* [**suppression.added**](/docs/webhooks/suppressions/added): triggered when an address is added.
* [**suppression.removed**](/docs/webhooks/suppressions/removed): triggered when an address is removed.

You can, for example, use these webhook notifications to sync your suppressions with your own database or third-party service.

## Export your Suppressions

You can export your suppressions as a CSV file from the [Suppressions page](https://resend.com/emails/suppressions). Click the **Download CSV** button to export your suppressions.

![Email Suppressions](https://mintcdn.com/resend/Nyu32IXsxRkmP92c/images/suppression-list-export.png?fit=max\&auto=format\&n=Nyu32IXsxRkmP92c\&q=85\&s=ff09fe52117ce4847a43126f84f58cc8)


# Embed Inline Images
Source: https://resend.com/docs/dashboard/emails/embed-inline-images

Send emails with inline images.

You can optionally embed an image in the HTML body of the email. This allows you to include images without needing to host them in an external server.

> [!NOTE]
>
> We currently do not support sending attachments (including inline images)
> [when using our batch endpoint](/docs/api-reference/emails/send-batch-emails).

**1. Add the CID in the email HTML.**

Use the prefix `cid:` to reference the ID in the `src` attribute of an image tag in the HTML body of the email.

```html theme={"theme":{"light":"github-light","dark":"vesper"}}
  <img src="cid:logo-image">
```

**2. Reference the CID in the attachment.**

Include the content id parameter in the attachment object (see below for example implementations). The ID is an arbitrary string set by you, and must be less than 128 characters.

## Implementation details

Both remote and local attachments are supported. All attachment [requirements, options, and limitations](/docs/dashboard/emails/attachments) apply to inline images as well.

As with all our features, inline images are available across all our SDKs.

### Remote image example

```ts Node.js {9, 14} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Thank you for contacting us',
  html: '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
  attachments: [
    {
      path: 'https://resend.com/static/sample/logo.png',
      filename: 'logo.png',
      contentId: 'logo-image',
    },
  ],
});
```

```php PHP {7,12} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'Thank you for contacting us',
  'html' => '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
  'attachments' => [
    [
      'path' => 'https://resend.com/static/sample/logo.png',
      'filename' => 'logo.png',
      'content_id' => 'logo-image',
    ]
  ]
]);
```

```python Python {8,15} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

attachment: resend.RemoteAttachment = {
  "path": "https://resend.com/static/sample/logo.png",
  "filename": "logo.png",
  "content_id": "logo-image",
}

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Thank you for contacting us",
  "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  "attachments": [attachment],
}

resend.Emails.send(params)
```

```rb Ruby {9, 14} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Thank you for contacting us",
  "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  "attachments": [
    {
      "path": "https://resend.com/static/sample/logo.png",
      "filename": 'logo.png',
      "content_id": "logo-image",
    }
  ]
}

Resend::Emails.send(params)
```

```go Go {17, 24} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  attachment := &resend.Attachment{
    Path:  "https://resend.com/static/sample/logo.png",
    Filename: "logo.png",
    ContentId: "logo-image",
  }

  params := &resend.SendEmailRequest{
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Subject:     "Thank you for contacting us",
      Html:        "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
      Attachments: []*resend.Attachment{attachment},
  }

  sent, err := client.Emails.SendWithContext(ctx, params)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Id)
}
```

```rust Rust {14, 17} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Thank you for contacting us";

  let path = "https://resend.com/static/sample/logo.png";
  let filename = "logo.png";
  let content_id = "logo-image";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
    .with_attachment(
      CreateAttachment::from_path(path)
        .with_filename(filename)
        .with_content_id(content_id),
    );

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {14, 21} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.Attachment;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Attachment att = Attachment.builder()
                .path("https://resend.com/static/sample/logo.png")
                .fileName("logo.png")
                .contentId("logo-image")
                .build();

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("Thank you for contacting us")
                .html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
                .attachments(att)
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {11, 18} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Collections.Generic;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var message = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "Thank you for contacting us",
    HtmlBody = "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
};

message.Attachments = new List<EmailAttachment>();
message.Attachments.Add( new EmailAttachment() {
  Filename = "logo.png",
  Path = "https://resend.com/static/sample/logo.png",
  ContentId = "logo-image",
} );

var resp = await resend.EmailSendAsync( message );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {8,13} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Thank you for contacting us",
  "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  "attachments": [
    {
      "path": "https://resend.com/static/sample/logo.png",
      "filename": "logo.png",
      "content_id": "logo-image"
    }
  ]
}'
```

### Local image example

```ts Node.js {13, 18} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import fs from 'fs';

const resend = new Resend('re_xxxxxxxxx');

const filepath = `${__dirname}/static/logo.png`;
const attachment = fs.readFileSync(filepath);

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Thank you for contacting us',
  html: '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
  attachments: [
    {
      content: attachment,
      filename: 'logo.png',
      contentId: 'logo-image',
    },
  ],
});
```

```php PHP {9, 14} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$attachment = base64_encode(file_get_contents(__DIR__ . '/static/logo.png'));

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'Thank you for contacting us',
  'html' => '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
  'attachments' => [
    [
      'filename' => 'logo.png',
      'content' => $attachment,
      'content_id' => 'logo-image',
    ]
  ]
]);
```

```python Python {10, 16} theme={"theme":{"light":"github-light","dark":"vesper"}}
import os
import resend

resend.api_key = "re_xxxxxxxxx"

f: bytes = open(
  os.path.join(os.path.dirname(__file__), "../static/logo.png"), "rb"
).read()

attachment: resend.Attachment = {"content": list(f), "filename": "logo.png", "content_id": "logo-image"}

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Thank you for contacting us",
  "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  "attachments": [attachment],
}

resend.Emails.send(params)
```

```rb Ruby {11,16} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

file = IO.read("logo.png")

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Thank you for contacting us",
  "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  "attachments": [
    {
      "content": file.bytes,
      "filename": 'logo.png',
      "content_id": "logo-image",
    }
  ]
}

Resend::Emails.send(params)
```

```go Go {24, 31} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"
	"os"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  pwd, _ := os.Getwd()
  f, err := os.ReadFile(pwd + "/static/logo.png")
  if err != nil {
    panic(err)
  }

  attachment := &resend.Attachment{
    Content:  f,
    Filename: "logo.png",
    ContentId: "logo-image",
  }

  params := &resend.SendEmailRequest{
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Subject:     "Thank you for contacting us",
      Html:        "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
      Attachments: []*resend.Attachment{attachment},
  }

  sent, err := client.Emails.SendWithContext(ctx, params)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Id)
}
```

```rust Rust {16,22} theme={"theme":{"light":"github-light","dark":"vesper"}}
use std::fs::File;
use std::io::Read;

use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Thank you for contacting us";

  let filename = "logo.png";
  let content_id = "logo-image";
  let mut f = File::open(filename).unwrap();
  let mut invoice = Vec::new();
  f.read_to_end(&mut invoice).unwrap();

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
    .with_attachment(
      CreateAttachment::from_content(invoice)
        .with_filename(filename)
        .with_content_id(content_id),
    );

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {14, 21} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.Attachment;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Attachment att = Attachment.builder()
                .fileName("logo.png")
                .content("invoiceBuffer")
                .contentId("logo-image")
                .build();

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("Thank you for contacting us")
                .html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
                .attachments(att)
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {12, 19} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Collections.Generic;
using System.IO;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var message = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "Thank you for contacting us",
    HtmlBody = "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
};

message.Attachments = new List<EmailAttachment>();
message.Attachments.Add( new EmailAttachment() {
  Filename = "logo.png",
  Content = await File.ReadAllBytesAsync( "logo.png" ),
  ContentId = "logo-image",
} );

var resp = await resend.EmailSendAsync( message );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {8, 13} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Thank you for contacting us",
  "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  "attachments": [
    {
      "content": "UmVzZW5kIGF0dGFjaG1lbnQgZXhhbXBsZS4gTmljZSBqb2Igc2VuZGluZyB0aGUgZW1haWwh%",
      "filename": "invoice.txt",
      "content_id": "logo-image"
    }
  ]
}'
```

## Other considerations

Before adding inline images, consider the following.

* As these images are sent as attachments, you need to encode your image as Base64 when sending the raw content via the API. There is no need to do this when passing the path of a remote image (the API handles this for you).
* Inline images increase the size of the email.
* Inline images may be rejected by some clients (especially webmail).
* As with all attachments, add a `content_type` (e.g. `image/png`) or `filename` (e.g. `logo.png`) parameter to the attachment object. This helps email clients render the attachment correctly.

> [!NOTE]
>
> All attachments (including inline images) do not currently display in the
> [emails dashboard](https://resend.com/emails) when previewing email HTML.


# Idempotency Keys
Source: https://resend.com/docs/dashboard/emails/idempotency-keys

Use idempotency keys to ensure that emails are sent only once.

Include an idempotency key in any email requests to ensure that the same email request is processed only once, even if it's sent multiple times.

> [!NOTE]
>
> Idempotency keys are currently supported on the following endpoints:
>
> * Emails: [Send Email](/docs/api-reference/emails/send-email) and [Send Email Batch](/docs/api-reference/emails/send-batch-emails)
> * Inboxes: [Send Draft](/docs/api-reference/inboxes/send-draft), [Reply to Thread Email](/docs/api-reference/inboxes/reply-thread-email) and [Forward Thread Email](/docs/api-reference/inboxes/forward-thread-email)

## How it works

When you send an email with an idempotency key, Resend checks whether an email with the same idempotency key has already been sent in the last 24 hours. This is an optional feature that simplifies managing retries on your side.

This makes it safe to retry requests that send an email. You don't have to worry about checking if the original request was sent. Instead, you can make the same request and our API will give the same response, without actually sending the email again.

## How to use idempotency keys

Idempotency keys can be up to 256 characters and must be unique per API request.

We recommend that you use a UUID or other string that uniquely identifies that specific email.

> [!TIP]
>
> If you have multiple events that trigger emails related to a single entity in your system, you can format your idempotency keys to take advantage of that entity's ID. One idea is to format idempotency keys like `<event-type>/<entity-id>`, for example `welcome-user/123456789`. The specific format you use is up to you.

Send the key in the `Idempotency-Key` HTTP header in your API requests. Our SDKs also provide a convenient way to set this header. If you're using SMTP, you can set the `Resend-Idempotency-Key` email header instead.

Idempotency keys are kept in the system for **24 hours**. This gives you an ample window to retry any failed processes on your end without having to keep track of the sent status.

### `POST /emails` endpoint example

```ts Node.js {13} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send(
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<p>it works!</p>',
  },
  {
    idempotencyKey: 'welcome-user/123456789',
  },
);
```

```php PHP {9} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'html' => '<p>it works!</p>',
], [
  'idempotency_key' => 'welcome-user/123456789',
]);
```

```python Python {13} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>"
}

options: resend.Emails.SendOptions = {
  "idempotency_key": "welcome-user/123456789",
}

resend.Emails.send(params, options)
```

```rb Ruby {13} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>"
}
Resend::Emails.send(
  params,
  options: { idempotency_key: "welcome-user/123456789" }
)
```

```go Go {13} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.SendEmailRequest{
		From:    "onboarding@resend.dev",
		To:      []string{"delivered@resend.dev"},
		Subject: "hello world",
		Html:    "<p>it works!</p>",
	}
	options := &resend.SendEmailOptions{
		IdempotencyKey: "welcome-user/123456789",
	}
	_, err := client.Emails.SendWithOptions(ctx, params, options)
	if err != nil {
		panic(err)
	}
}
```

```rust Rust {14} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Hello World";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>it works!</p>")
    .with_idempotency_key("welcome-user/123456789");

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {16} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.net.RequestOptions;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;

Resend resend = new Resend("re_xxxxxxxxx");

CreateEmailOptions params = CreateEmailOptions.builder()
  .from("Acme <onboarding@resend.dev>")
  .to("delivered@resend.dev")
  .subject("hello world")
  .html("<p>it works!</p>")
  .build();

RequestOptions options = RequestOptions.builder()
  .setIdempotencyKey("welcome-user/123456789").build();

CreateEmailResponse data = resend.emails().send(params, options);
```

```csharp C# {11} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var key = IdempotencyKey.New<int>( "welcome-user", 123456789 );
var resp = await resend.EmailSendAsync(key, new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
} );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {4} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -H 'Idempotency-Key: welcome-user/123456789' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>"
}'
```

```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "hello world" \
  --html "<p>it works!</p>" \
  --idempotency-key "welcome-user/123456789"
```

```yaml SMTP {4} theme={"theme":{"light":"github-light","dark":"vesper"}}
From: Acme <onboarding@resend.dev>
To: delivered@resend.dev
Subject: hello world
Resend-Idempotency-Key: welcome-user/123456789

<p>it works!</p>
```

### `POST /emails/batch` endpoint example

> [!TIP]
>
> Format your idempotency keys to take advantage of that entity's ID (i.e.,
> `<event-type>/<entity-id>`). For batch sends, choose a key that represents the whole batch, like a team, workspace, or project (i.e., `team-quota/123456789`).

```ts Node.js {21} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.batch.send(
  [
    {
      from: 'Acme <onboarding@resend.dev>',
      to: ['foo@gmail.com'],
      subject: 'hello world',
      html: '<h1>it works!</h1>',
    },
    {
      from: 'Acme <onboarding@resend.dev>',
      to: ['bar@outlook.com'],
      subject: 'world hello',
      html: '<p>it works!</p>',
    },
  ],
  {
    idempotencyKey: 'team-quota/123456789',
  },
);
```

```php PHP {19} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->batch->send(
  [
    [
      'from' => 'Acme <onboarding@resend.dev>',
      'to' => ['foo@gmail.com'],
      'subject' => 'hello world',
      'html' => '<h1>it works!</h1>',
    ],
    [
      'from' => 'Acme <onboarding@resend.dev>',
      'to' => ['bar@outlook.com'],
      'subject' => 'world hello',
      'html' => '<p>it works!</p>',
    ]
  ],
  [
    'idempotency_key' => 'team-quota/123456789',
  ]
);
```

```py Python {22} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend
from typing import List

resend.api_key = "re_xxxxxxxxx"

params: List[resend.Emails.SendParams] = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
  }
]

options: resend.Batch.SendOptions = {
  "idempotency_key": "team-quota/123456789",
}

resend.Batch.send(params, options)
```

```rb Ruby {22} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = 're_xxxxxxxxx'

params = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
  }
]

Resend::Batch.send(
  params,
  options: { idempotency_key: "team-quota/123456789" }
)
```

```go Go {32} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {

  ctx := context.TODO()

  client := resend.NewClient("re_xxxxxxxxx")

  var batchEmails = []*resend.SendEmailRequest{
    {
      From:    "Acme <onboarding@resend.dev>",
      To:      []string{"foo@gmail.com"},
      Subject: "hello world",
      Html:    "<h1>it works!</h1>",
    },
    {
      From:    "Acme <onboarding@resend.dev>",
      To:      []string{"bar@outlook.com"},
      Subject: "world hello",
      Html:    "<p>it works!</p>",
    },
  }

  options := &resend.BatchSendEmailOptions{
    IdempotencyKey: "team-quota/123456789",
  }

  sent, err := client.Batch.SendWithOptions(ctx, batchEmails, options)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Data)
}
```

```rust Rust {22} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{idempotent::IdempotentTrait, types::CreateEmailBaseOptions};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let emails = vec![
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["foo@gmail.com"],
      "hello world",
    )
    .with_html("<h1>it works!</h1>"),
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["bar@outlook.com"],
      "world hello",
    )
    .with_html("<p>it works!</p>"),
  ]
  .with_idempotency_key("team-quota/123456789");

  let _emails = resend.batch.send(emails).await?;

  Ok(())
}
```

```java Java {28} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.core.net.RequestOptions;
import com.resend.services.batch.model.CreateBatchEmailsResponse;
import com.resend.services.emails.model.CreateEmailOptions;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions firstEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("foo@gmail.com")
            .subject("hello world")
            .html("<h1>it works!</h1>")
            .build();

        CreateEmailOptions secondEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("bar@outlook.com")
            .subject("world hello")
            .html("<p>it works!</p>")
            .build();

        CreateBatchEmailsResponse data = resend.batch().send(
            Arrays.asList(firstEmail, secondEmail),
            RequestOptions.builder().setIdempotencyKey("team-quota/123456789").build()
        );
    }
}
```

```csharp .NET {5} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var key = IdempotencyKey.New<int>( "team-quota", 123456789 );

var mail1 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "foo@gmail.com",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
};

var mail2 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "bar@outlook.com",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
};

var resp = await resend.EmailBatchAsync(key, [ mail1, mail2 ] );
Console.WriteLine( "Nr Emails={0}", resp.Content.Count );
```

```bash cURL {4} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails/batch' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -H 'Idempotency-Key: team-quota/123456789' \
     -d $'[
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>"
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>"
  }
]'
```

## Possible responses

After checking if an email with the same idempotency key has already been sent, Resend returns one of the following responses:

* **Successful responses** will return the email ID of the sent email.
* **Error responses** will return one of the following errors:
  * `400`: `invalid_idempotency_key` - the idempotency key has to be between 1–256 characters. You can retry with a valid key or without supplying an idempotency key.
  * `409`: `invalid_idempotent_request` - this idempotency key has already been used on a request that had a different payload. Retrying this request is useless without changing the idempotency key or payload.
  * `409`: `concurrent_idempotent_requests` - another request with the same idempotency key is in progress. As it isn't finished yet, Resend can't return its original response, but it is safe to retry this request later if needed.


# Sending Emails
Source: https://resend.com/docs/dashboard/emails/introduction

An introduction to sending emails with Resend.

## Sending transactional emails

Resend provides all the tools you need to send [transactional emails](/docs/email-types#send-transactional-emails) from your application. These are useful for:

* order confirmations
* password reset emails
* account notifications

> [!TIP]
>
> To send bulk marketing emails, use the
> [Broadcasts](/docs/dashboard/broadcasts/introduction) feature.

Once you [verify a domain](/docs/add-a-domain) in your Resend account, you can send from any email address at that domain. You do not need to “create an email address,” “set up a sender identity,” or “add a from-address” before sending.

## Sending Features

With Resend's email sending features, you can:

* Send, retrieve, cancel, and manage individual and transactional email delivery through the [Sending API](/docs/api-reference/emails/send-email) and [SDKs](/docs/sdks), [CLI commands](/docs/cli#emails), [automations](/docs/dashboard/automations/introduction), and [AI building tools](/docs/ai-onboarding).
* [View and manage all sent emails](/docs/dashboard/emails/manage-emails) in the Emails Dashboard page.
* Send single or [batch transactional emails](/docs/dashboard/emails/batch-sending).
* [Schedule emails](/docs/dashboard/emails/schedule-email) to be sent at a future date.
* Send emails [with attachments](/docs/dashboard/emails/attachments) and [embedded images](/docs/dashboard/emails/embed-inline-images).
* Include [custom headers](/docs/dashboard/emails/custom-headers) in your emails.
* Use [idempotency keys](/docs/dashboard/emails/idempotency-keys) to ensure emails are sent only once.
* Receive tailored [deliverability insights](/docs/dashboard/emails/deliverability-insights) about each email with suggestions for improvement.
* [View API endpoint logs](/docs/dashboard/logs/introduction) and deliverability metrics for monitoring and troubleshooting.

## Quickstart

Get started with a [quick setup sending example](/docs/introduction#quickstart) for your language or an [AI builder guide](/docs/ai-onboarding#ai-builder-guides) to see how to incorporate Resend into your application.

## Choose your infrastructure

To send transactional emails from your application, you can use a variety of tools:

* [SDK](/docs/sdks): send with an SDK built for your language
* [Integrations](/docs/integrations): send from a framework or tool you already use
* [API](/docs/api-reference/emails/send-email): send with raw cURL calls
* [CLI](/docs/cli#emails): send emails from the terminal
* [MCP](/docs/mcp-server): send through your agent with MCP (see also [skills](/docs/react-email-skill))
* [SMTP](/docs/send-with-smtp): send without external dependencies

You can also send emails as part of [automated workflows](/docs/dashboard/automations/introduction) such as abandoned cart reminders, and create [email templates](/docs/dashboard/templates/introduction) for repeatable content.

See how to use additional sending features, including scheduling and attachments, in the [sending email guides](#related-guides).

## Manage your sent emails

After you've sent or scheduled your first email, you'll be able to view and manage your emails in the [Emails Dashboard page](https://resend.com/emails). From here, you can view email details, share a public version, and more. This allows all members of your team to view and manage your sent emails.

You can also manage your emails programmatically using the [Sending API](/docs/api-reference/emails/send-email), [CLI commands](/docs/cli#emails), or the [MCP server](/docs/mcp-server).

Learn more about [managing your sent emails](/docs/dashboard/emails/manage-emails) in the dedicated guide.

## Related Guides

See how to use Resend's sending features.

> [card] [View and manage sent emails](/docs/dashboard/emails/manage-emails)

> [card] [Send test emails](/docs/dashboard/emails/send-test-emails)

> [card] [Include attachments](/docs/dashboard/emails/attachments)

> [card] [Embed inline images](/docs/dashboard/emails/embed-inline-images)

> [card] [Schedule emails](/docs/dashboard/emails/schedule-email)

> [card] [Batch sending](/docs/dashboard/emails/batch-sending)

> [card] [Customize headers](/docs/dashboard/emails/custom-headers)

> [card] [Prevent duplicate emails](/docs/dashboard/emails/idempotency-keys)

> [card] [Add an unsubscribe link](/docs/dashboard/emails/add-unsubscribe-to-transactional-emails)

> [card] [Add identifier tags](/docs/dashboard/emails/tags)


# View and manage emails
Source: https://resend.com/docs/dashboard/emails/manage-emails

An introduction to managing your sent emails with Resend.

## Manage your sent emails

After you've sent or scheduled your first email, your emails appear in the [**Emails** Dashboard page](https://resend.com/emails). You can [view email details](#view-email-details), [share a public version](#share-email-link), [view email logs](#see-associated-logs), and more.

You can also manage your scheduled and sent emails using Resend's code tools including the [MCP server](/docs/mcp-server), [API endpoints](/docs/api-reference/emails/send-email) and [CLI commands](/docs/cli#emails) for tasks such as listing, sending, updating, and canceling emails.

## View email details

See all the metadata associated with a sent or scheduled email, including the sender address, recipient address, subject, and more from the [**Emails** Dashboard page](https://resend.com/emails). Select any email to view its details.

![Email Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-emails-item.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=406e90f545d6b4f4289cd86311a2642a)

Each email contains a **Preview**, **Plain Text**, and **HTML** version to visualize the content of your sent email in its various formats.

## Understand email events

Here are all the events that can be associated with an email:

* `bounced` - The recipient's mail server rejected the email. ([Learn more about bounced emails](/docs/dashboard/emails/email-bounces))
* `canceled` - The scheduled email was canceled (by user).
* `clicked` - The recipient clicked on a link in the email.
* `complained` - The email was successfully delivered to the recipient's mail server, but the recipient marked it as spam.
* `delivered` - Resend successfully delivered the email to the recipient's mail server.
* `delivery_delayed` - The email couldn't be delivered to the recipient's mail server because a temporary issue occurred. Delivery delays can occur, for example, when the recipient's inbox is full, or when the receiving email server experiences a transient issue. Resend keeps retrying automatically for up to 14 hours. If the recipient's mail server still hasn't accepted the email by then, it's marked as `bounced`.
* `failed` - The email failed to be sent.
* `opened` - The recipient opened the email. ([Open rates are not always accurate](/docs/knowledge-base/why-are-my-open-rates-not-accurate))
* `queued` - The email created from Broadcasts or Batches is queued for delivery.
* `scheduled` - The email is scheduled for delivery.
* `sent` - The email was sent successfully.
* `suppressed` - The email was not sent because the recipient is on the suppression list. ([Learn more about the suppression list](/docs/knowledge-base/why-are-my-emails-landing-on-the-suppression-list))

## Share email link

You can share a public link of a sent email, which is valid for 48 hours. Anyone with the link can view the email.

To share a link, click on the **dropdown menu** , and select **Share email**.

![Email - Share Link Option](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-emails-share-option.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=1e3019a33d90161bc41a77817e2a54c5)

Copy the URL and share it with your team members.

![Email - Share Link Modal](https://mintcdn.com/resend/X9PImr4lu4mKo3Cs/images/dashboard-emails-share-modal.png?fit=max\&auto=format\&n=X9PImr4lu4mKo3Cs\&q=85\&s=26ec7bc493175030c8f99a2022774de3)

Anyone with the link can view the email without authenticating for 48 hours.

![Email - Share Link Item](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-emails-share-item.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=05c438ac1b5e0721475b3f028a6f6934)

You can also create share links programmatically using the [Share Email API](/docs/api-reference/emails/share-email).

## See associated logs

Check all the logs associated with an email to help you troubleshoot any issues with the request itself.

To view the logs, click on the dropdown menu, and select "View log".

![Email - View Logs Option](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-emails-log-option.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=ad69ba9d638fe43f62974a0d76b1e01e)

This will take you to logs, where you can see all the logs associated with the email.

![Email - View Logs Item](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-emails-log-item.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=936f066559e1ae477523be37aa959f90)

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

> [!NOTE]
>
> Currently, exports are limited to admin users of your team.

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

> [!NOTE]
>
> All exports your team creates are listed in the
> [Exports](https://resend.com/exports) page under **Settings** > **Team** >
> **Exports**. Select any export to view its details page. All members of your
> team can view your exports, but only admins can download the data.

## API Reference

For complete API documentation, see the [Sending API reference](/docs/api-reference/emails/send-email).


# Schedule Email
Source: https://resend.com/docs/dashboard/emails/schedule-email

Send emails at a specific time without additional complexity.

While some emails need to be delivered as soon as possible, like password resets or magic links, others can be scheduled for a specific time.

Here are some examples of when you might want to schedule an email:

* Send welcome email **5 minutes after** signup
* Trigger a reminder email **24 hours before** an event
* Schedule a weekly digest email for the **next day at 9am PST**

Before, you had to use external services to handle the scheduling logic, but now you can use the new Resend API to schedule emails.

> [!NOTE]
>
> Emails can be scheduled up to 30 days in advance.

There are two ways to schedule an email:

1. [Using natural language](#schedule-using-natural-language)
2. [Using date format](#schedule-using-date-format)

## Schedule using natural language

You can use the various Resend SDKs to schedule emails.

The date can be defined using natural language, such as `"in 1 hour"`, `"tomorrow at 9am"`, or `"Friday at 3pm ET"`.

```ts Node.js {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'hello world',
  html: '<p>it works!</p>',
  scheduledAt: 'in 1 min',
});
```

```php PHP {8} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'html' => '<p>it works!</p>',
  'scheduled_at' => 'in 1 min'
]);
```

```python Python {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "scheduled_at": "in 1 min"
}

resend.Emails.send(params)
```

```rb Ruby {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "scheduled_at": "in 1 min"
}

Resend::Emails.send(params)
```

```go Go {17} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.SendEmailRequest{
		From:        "Acme <onboarding@resend.dev>",
		To:          []string{"delivered@resend.dev"},
		Subject:     "hello world",
		Html:        "<p>it works!</p>",
		ScheduledAt: "in 1 min",
	}

	sent, err := client.Emails.SendWithContext(ctx, params)

	if err != nil {
		panic(err)
	}
	fmt.Println(sent.Id)
}
```

```rust Rust {14} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "hello world";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>it works!</p>")
    .with_scheduled_at("in 1 min");

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {15} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("hello world")
                .html("<p>it works!</p>")
                .scheduledAt("in 1 min")
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {11} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailSendAsync( new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
    MomentSchedule = "in 1 min",
} );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {9} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "scheduled_at": "in 1 min"
}'
```

```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "hello world" \
  --html "<p>it works!</p>" \
  --scheduled-at "in 1 min"
```

## Schedule using date format

You can also use a date in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format (e.g: `2026-08-05T11:52:01.858Z`).

```ts Node.js {5} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const oneMinuteFromNow = new Date(Date.now() + 1000 * 60).toISOString();

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'hello world',
  html: '<p>it works!</p>',
  scheduledAt: oneMinuteFromNow,
});
```

```php PHP {3} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$oneMinuteFromNow = (new DateTime())->modify('+1 minute')->format(DateTime::ISO8601);

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'html' => '<p>it works!</p>',
  'scheduled_at' => $oneMinuteFromNow
]);
```

```python Python {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend
from datetime import datetime, timedelta

resend.api_key = "re_xxxxxxxxx"

one_minute_from_now = (datetime.now() + timedelta(minutes=1)).isoformat()

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "scheduled_at": one_minute_from_now
}

resend.Emails.send(params)
```

```rb Ruby {5} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

one_minute_from_now = (Time.now + 1 * 60).strftime("%Y-%m-%dT%H:%M:%S.%L%z")

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "scheduled_at": one_minute_from_now
}

Resend::Emails.send(params)
```

```go Go {13} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/resend/resend-go/v4"
)

func main() {
	ctx := context.TODO()
	client := resend.NewClient("re_xxxxxxxxx")

	oneMinuteFromNow := time.Now().Add(time.Minute * time.Duration(1))
	oneMinuteFromNowISO := oneMinuteFromNow.Format("2006-01-02T15:04:05-0700")

	params := &resend.SendEmailRequest{
		From:        "Acme <onboarding@resend.dev>",
		To:          []string{"delivered@resend.dev"},
		Subject:     "hello world",
		Html:        "<p>it works!</p>",
		ScheduledAt: oneMinuteFromNowISO,
	}

	sent, err := client.Emails.SendWithContext(ctx, params)

	if err != nil {
		panic(err)
	}
	fmt.Println(sent.Id)
}
```

```rust Rust {12-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
use chrono::{Local, TimeDelta};
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "hello world";
  let one_minute_from_now = Local::now()
    .checked_add_signed(TimeDelta::minutes(1))
    .unwrap()
    .to_rfc3339();

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>it works!</p>")
    .with_scheduled_at(&one_minute_from_now);

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {12-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;
import java.time.Instant;
import java.time.temporal.ChronoUnit;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        String oneMinuteFromNow = Instant
          .now()
          .plus(1, ChronoUnit.MINUTES)
          .toString();

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("hello world")
                .html("<p>it works!</p>")
                .scheduledAt(oneMinuteFromNow)
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {11} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailSendAsync( new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
    MomentSchedule = DateTime.UtcNow.AddMinutes( 1 ),
} );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {9} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "scheduled_at": "2026-08-20T11:52:01.858Z"
}'
```

```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "hello world" \
  --html "<p>it works!</p>" \
  --scheduled-at "2026-08-20T11:52:01.858Z"
```

## Schedule emails on the `POST /emails/batch` endpoint

Each email in a batch request can be scheduled independently using natural language or ISO 8601 date format.

```ts Node.js {11,18} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.batch.send([
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['foo@gmail.com'],
    subject: 'hello world',
    html: '<h1>it works!</h1>',
    scheduledAt: 'in 1 min',
  },
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['bar@outlook.com'],
    subject: 'world hello',
    html: '<p>it works!</p>',
    scheduledAt: 'in 5 min',
  },
]);
```

```php PHP {9,16} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->batch->send([
  [
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['foo@gmail.com'],
    'subject' => 'hello world',
    'html' => '<h1>it works!</h1>',
    'scheduled_at' => 'in 1 min'
  ],
  [
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['bar@outlook.com'],
    'subject' => 'world hello',
    'html' => '<p>it works!</p>',
    'scheduled_at' => 'in 5 min'
  ]
]);
```

```py Python {12,19} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend
from typing import List

resend.api_key = "re_xxxxxxxxx"

params: List[resend.Emails.SendParams] = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
    "scheduled_at": "in 1 min"
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
    "scheduled_at": "in 5 min"
  }
]

resend.Batch.send(params)
```

```rb Ruby {11,18} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = 're_xxxxxxxxx'

params = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
    "scheduled_at": "in 1 min"
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
    "scheduled_at": "in 5 min"
  }
]

Resend::Batch.send(params)
```

```go Go {22,29} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {

  ctx := context.TODO()

  client := resend.NewClient("re_xxxxxxxxx")

  var batchEmails = []*resend.SendEmailRequest{
    {
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"foo@gmail.com"},
      Subject:     "hello world",
      Html:        "<h1>it works!</h1>",
      ScheduledAt: "in 1 min",
    },
    {
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"bar@outlook.com"},
      Subject:     "world hello",
      Html:        "<p>it works!</p>",
      ScheduledAt: "in 5 min",
    },
  }

  sent, err := client.Batch.SendWithContext(ctx, batchEmails)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Data)
}
```

```rust Rust {15,22} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let emails = vec![
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["foo@gmail.com"],
      "hello world",
    )
    .with_html("<h1>it works!</h1>")
    .with_scheduled_at("in 1 min"),
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["bar@outlook.com"],
      "world hello",
    )
    .with_html("<p>it works!</p>")
    .with_scheduled_at("in 5 min"),
  ];

  let _emails = resend.batch.send(emails).await?;

  Ok(())
}
```

```java Java {16,24} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.batch.model.CreateBatchEmailsResponse;
import com.resend.services.emails.model.CreateEmailOptions;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions firstEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("foo@gmail.com")
            .subject("hello world")
            .html("<h1>it works!</h1>")
            .scheduledAt("in 1 min")
            .build();

        CreateEmailOptions secondEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("bar@outlook.com")
            .subject("world hello")
            .html("<p>it works!</p>")
            .scheduledAt("in 5 min")
            .build();

        CreateBatchEmailsResponse data = resend.batch().send(
            Arrays.asList(firstEmail, secondEmail)
        );
    }
}
```

```csharp .NET {11,20} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var mail1 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "foo@gmail.com",
    Subject = "hello world",
    HtmlBody = "<h1>it works!</h1>",
    MomentSchedule = "in 1 min",
};

var mail2 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "bar@outlook.com",
    Subject = "world hello",
    HtmlBody = "<p>it works!</p>",
    MomentSchedule = "in 5 min",
};

var resp = await resend.EmailBatchAsync( [ mail1, mail2 ] );
Console.WriteLine( "Nr Emails={0}", resp.Content.Count );
```

```bash cURL {10,17} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails/batch' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'[
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
    "scheduled_at": "in 1 min"
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
    "scheduled_at": "in 5 min"
  }
]'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
# Each email in emails.json can set its own scheduled_at
resend emails batch --file ./emails.json
```

## View a scheduled email

Once you schedule an email, you can see the scheduled time in the Resend dashboard.

<video />

## Reschedule an email

After scheduling an email, you might need to update the scheduled time.

You can do so with the following method:

```ts Node.js {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

resend.emails.update({
  id: '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794',
  scheduledAt: 'in 1 min',
});
```

```php PHP {4} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->update('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794', [
  'scheduled_at' => 'in 1 min'
]);
```

```python Python {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

update_params: resend.Emails.UpdateParams = {
  "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  "scheduled_at": "in 1 min"
}

resend.Emails.update(params=update_params)
```

```rb Ruby {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

update_params = {
  "email_id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
  "scheduled_at": "in 1 min"
}

updated_email = Resend::Emails.update(update_params)
```

```go Go {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	updateParams := &resend.UpdateEmailRequest{
		Id:          "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
		ScheduledAt: "in 1 min",
	}

	updatedEmail, err := client.Emails.Update(updateParams)

	if err != nil {
		panic(err)
	}
	fmt.Printf("%v\n", updatedEmail)
}
```

```rust Rust {9} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::UpdateEmailOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let update = UpdateEmailOptions::new()
    .with_scheduled_at("in 1 min");

  let _email = resend
    .emails
    .update("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", update)
    .await?;

  Ok(())
}
```

```java Java {8} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.services.emails.model.UpdateEmailOptions;
import com.resend.services.emails.model.UpdateEmailResponse;

Resend resend = new Resend("re_xxxxxxxxx");

UpdateEmailOptions updateParams = UpdateEmailOptions.builder()
  .scheduledAt("in 1 min")
  .build();

UpdateEmailResponse data = resend.emails().update("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", updateParams);
```

```csharp .NET {7} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.EmailRescheduleAsync(
  new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ),
  "in 1 min"
);
```

```bash cURL {5} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/emails/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "scheduled_at": "in 1 min"
}'
```

```bash CLI {2} theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails update 49a3999c-0ce1-4ea6-ab68-afcd6dc2e794 \
  --scheduled-at "in 1 min"
```

You can also reschedule an email directly in the Resend Dashboard.

<video />

## Cancel a scheduled email

> [!WARNING]
>
> Once an email is canceled, it cannot be rescheduled.

If you need to cancel a scheduled email, you can do so with the following code:

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

resend.emails.cancel('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794');
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->cancel('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Emails.cancel(email_id="49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
```

```rb Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Emails.cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	canceled, err := client.Emails.Cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
	if err != nil {
		panic(err)
	}
	fmt.Println(canceled.Id)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _canceled = resend
    .emails
    .cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.services.emails.model.CancelEmailResponse;

Resend resend = new Resend("re_xxxxxxxxx");

CancelEmailResponse canceled = resend
    .emails()
    .cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794");
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.EmailCancelAsync( new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794/cancel' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails cancel 49a3999c-0ce1-4ea6-ab68-afcd6dc2e794
```

You can also cancel a scheduled email in the Resend dashboard.

<video />

## Scheduled email failures

Scheduled emails may fail to send for several reasons. When this happens, you'll see a failure notification in the email details screen with specific information about why the email couldn't be sent.

Common failure reasons include:

* **API key is no longer active** - The API key used to schedule the email has been deleted, expired, or suspended. The email cannot be sent.
* **Account under review** - Your account has been flagged for review and sending has been temporarily suspended. Contact [support@resend.com](mailto:support@resend.com) if you believe this is an error.

You can view the failure reason and details in the Resend dashboard by clicking on the failed email.

## Limitations

* Emails sent via SMTP cannot be scheduled

## Try it yourself

> [card] [Next.js (TypeScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/scheduling)
>
> See the full source code.

> [card] [Next.js (JavaScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/scheduling)
>
> See the full source code.

> [card] [PHP](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/scheduling)
>
> See the full source code.

> [card] [Laravel](https://github.com/resend/resend-examples/tree/main/laravel-resend-examples)
>
> See the full source code.

> [card] [Python](https://github.com/resend/resend-examples/tree/main/python-resend-examples/examples)
>
> See the full source code.

> [card] [Ruby](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples)
>
> See the full source code.


# Send Test Emails
Source: https://resend.com/docs/dashboard/emails/send-test-emails

Simulate different events by sending test emails.

## How to send test emails

During development, it's important to test different deliverability scenarios.

> **Example**: When an email hard bounces or is marked as spam, it's important to stop sending emails to the recipient, as continuing to send emails to those addresses will damage your domain reputation. Consider [creating a webhook endpoint](/docs/webhooks/introduction) to capture these events and remove the addresses from your mailing lists.

When testing, avoid:

* sending to fake email addresses
* setting up a fake SMTP server

Use the provided `resend.dev` test email addresses to simulate different email events without damaging your domain reputation. These test emails enable the safe use of Resend's Dashboard, Webhooks, and API when developing your application.

> [!NOTE]
>
> Test emails count against your account's sending quota.

All test email addresses support labeling, which enables you to send emails to the same test address in multiple ways. You can add a label after the `+` symbol (e.g., `delivered+label1@resend.dev`) to help track and differentiate between different test scenarios in your application.

## Test delivered emails

To test that your emails are being successfully delivered, you can send an email to:

```
delivered@resend.dev
```

With labeling support, you can also use:

```
delivered+user1@resend.dev
delivered+user2@resend.dev
delivered+user3@resend.dev
```

## Test bounced emails

To test that the recipient's email provider rejected your email, you can send an email to:

```
bounced@resend.dev
```

With labeling support, you can also use:

```
bounced+user1@resend.dev
bounced+user2@resend.dev
bounced+user3@resend.dev
```

This will generate a SMTP 550 5.1.1 ("Unknown User") response code.

## Test "Marked as Spam" emails

To test that your emails are being received but marked as spam, you can send an email to:

```
complained@resend.dev
```

With labeling support, you can also use:

```
complained+user1@resend.dev
complained+user2@resend.dev
complained+user3@resend.dev
```

## Test suppressed emails

To test that your emails are being suppressed, you can send an email to:

```
suppressed@resend.dev
```

> [!NOTE]
>
> When using this test email, the suppression reason will indicate the address
> was previously bounced

## Using labels effectively

> [!WARNING]
>
> The suppressed test email address does not support labeling yet

The labeling feature allows you to use any string as a label after the `+` symbol. This is particularly useful for:

* Testing different email flows (e.g., `delivered+signup@resend.dev`, `delivered+password-reset@resend.dev`)
* Tracking webhook responses for specific test scenarios
* Differentiating between multiple test runs
* Matching responses with the specific email address that triggered the event


# Managing Tags
Source: https://resend.com/docs/dashboard/emails/tags

Add unique identifiers to emails sent.

Tags are unique identifiers you can add to your emails. They help associate emails with your application. They are passed in key/value pairs. After the email is sent, the tag is included in the webhook event. Tags can include ASCII letters, numbers, underscores, or dashes. You can add up to 75 tags per email.

Some examples of when to use a tag:

* Associate the email a "customer ID" from your application
* Add a label from your database like "free" or "enterprise"
* Note the category of email sent, like "welcome" or "password reset"

Here's how you can add custom tags to your emails.

## Add tags on the `POST /emails` endpoint

```ts Node.js {10-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'hello world',
  html: '<p>it works!</p>',
  tags: [
    {
      name: 'category',
      value: 'confirm_email',
    },
  ],
});
```

```php PHP {8-13} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'html' => '<p>it works!</p>',
  'tags' => [
    [
      'name' => 'category',
      'value' => 'confirm_email',
    ],
  ]
]);
```

```python Python {10-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "tags": [
    {"name": "category", "value": "confirm_email"},
  ],
}

email = resend.Emails.send(params)
print(email)
```

```rb Ruby {10-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "tags": [
    {"name": "category", "value": "confirm_email"}
  ]
}

sent = Resend::Emails.send(params)
puts sent
```

```go Go {19} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.SendEmailRequest{
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Text:        "<p>it works!</p>",
      Subject:     "hello world",
      Tags:        []resend.Tag{{Name: "category", Value: "confirm_email"}},
  }

  sent, err := client.Emails.SendWithContext(ctx, params)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Id)
}
```

```rust Rust {14} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::{CreateEmailBaseOptions, Tag};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "hello world";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<p>it works!</p>")
    .with_tag(Tag::new("category", "confirm_email"));

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {21} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;
import com.resend.services.emails.model.Tag;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Tag tag = Tag.builder()
                .name("category")
                .value("confirm_email")
                .build();

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("hello world")
                .html("<p>it works!</p>")
                .tags(tag)
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {12} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailSendAsync( new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
    ReplyTo = "onboarding@resend.dev",
    Tags = new List<EmailTag> { new EmailTag { Name = "category", Value = "confirm_email" } }
} );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL {9-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<p>it works!</p>",
  "tags": [
    {
      "name": "category",
      "value": "confirm_email"
    }
  ]
}'
```

```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "hello world" \
  --html "<p>it works!</p>" \
  --tags "category=confirm_email"
```

## Add tags on the `POST /emails/batch` endpoint

```ts Node.js {11-16,23-28} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.batch.send([
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['foo@gmail.com'],
    subject: 'hello world',
    html: '<h1>it works!</h1>',
    tags: [
      {
        name: 'category',
        value: 'confirm_email',
      },
    ],
  },
  {
    from: 'Acme <onboarding@resend.dev>',
    to: ['bar@outlook.com'],
    subject: 'world hello',
    html: '<p>it works!</p>',
    tags: [
      {
        name: 'category',
        value: 'confirm_email',
      },
    ],
  },
]);
```

```php PHP {9-13,21-25} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->batch->send([
  [
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['foo@gmail.com'],
    'subject' => 'hello world',
    'html' => '<h1>it works!</h1>',
    'tags' => [
      [
        'name' => 'category',
        'value' => 'confirm_email'
      ]
    ]
  ],
  [
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['bar@outlook.com'],
    'subject' => 'world hello',
    'html' => '<p>it works!</p>',
    'tags' => [
      [
        'name' => 'category',
        'value' => 'confirm_email'
      ]
    ]
  ]
]);
```

```py Python {12-17,24-29} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend
from typing import List

resend.api_key = "re_xxxxxxxxx"

params: List[resend.Emails.SendParams] = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
    "tags": [
      {
        "name": "category",
        "value": "confirm_email"
      }
    ]
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
    "tags": [
      {
        "name": "category",
        "value": "confirm_email"
      }
    ]
  }
]

resend.Batch.send(params)
```

```rb Ruby {11-16,23-28} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = 're_xxxxxxxxx'

params = [
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
    "tags": [
      {
        "name": "category",
        "value": "confirm_email"
      }
    ]
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
    "tags": [
      {
        "name": "category",
        "value": "confirm_email"
      }
    ]
  }
]

Resend::Batch.send(params)
```

```go Go {22,29} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {

  ctx := context.TODO()

  client := resend.NewClient("re_xxxxxxxxx")

  var batchEmails = []*resend.SendEmailRequest{
    {
      From:    "Acme <onboarding@resend.dev>",
      To:      []string{"foo@gmail.com"},
      Subject: "hello world",
      Html:    "<h1>it works!</h1>",
      Tags:    []resend.Tag{{Name: "category", Value: "confirm_email"}},
    },
    {
      From:    "Acme <onboarding@resend.dev>",
      To:      []string{"bar@outlook.com"},
      Subject: "world hello",
      Html:    "<p>it works!</p>",
      Tags:    []resend.Tag{{Name: "category", Value: "confirm_email"}},
    },
  }

  sent, err := client.Batch.SendWithContext(ctx, batchEmails)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Data)
}
```

```rust Rust {15,22} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::{CreateEmailBaseOptions, Tag};
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let emails = vec![
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["foo@gmail.com"],
      "hello world",
    )
    .with_html("<h1>it works!</h1>")
    .with_tag(Tag::new("category", "confirm_email")),
    CreateEmailBaseOptions::new(
      "Acme <onboarding@resend.dev>",
      vec!["bar@outlook.com"],
      "world hello",
    )
    .with_html("<p>it works!</p>")
    .with_tag(Tag::new("category", "confirm_email")),
  ];

  let _emails = resend.batch.send(emails).await?;

  Ok(())
}
```

```java Java {17-20,28-31} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.batch.model.CreateBatchEmailsResponse;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.Tag;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions firstEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("foo@gmail.com")
            .subject("hello world")
            .html("<h1>it works!</h1>")
            .tags(Tag.builder()
                .name("category")
                .value("confirm_email")
                .build())
            .build();

        CreateEmailOptions secondEmail = CreateEmailOptions.builder()
            .from("Acme <onboarding@resend.dev>")
            .to("bar@outlook.com")
            .subject("world hello")
            .html("<p>it works!</p>")
            .tags(Tag.builder()
                .name("category")
                .value("confirm_email")
                .build())
            .build();

        CreateBatchEmailsResponse data = resend.batch().send(
            Arrays.asList(firstEmail, secondEmail)
        );
    }
}
```

```csharp .NET {11,20} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var mail1 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "foo@gmail.com",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
    Tags = new List<EmailTag> { new EmailTag { Name = "category", Value = "confirm_email" } }
};

var mail2 = new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "bar@outlook.com",
    Subject = "hello world",
    HtmlBody = "<p>it works!</p>",
    Tags = new List<EmailTag> { new EmailTag { Name = "category", Value = "confirm_email" } }
};

var resp = await resend.EmailBatchAsync( [ mail1, mail2 ] );
Console.WriteLine( "Nr Emails={0}", resp.Content.Count );
```

```bash cURL {10-15,22-27} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails/batch' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'[
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["foo@gmail.com"],
    "subject": "hello world",
    "html": "<h1>it works!</h1>",
    "tags": [
      {
        "name": "category",
        "value": "confirm_email"
      }
    ]
  },
  {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["bar@outlook.com"],
    "subject": "world hello",
    "html": "<p>it works!</p>",
    "tags": [
      {
        "name": "category",
        "value": "confirm_email"
      }
    ]
  }
]'
```


# Inboxes
Source: https://resend.com/docs/dashboard/inboxes/introduction

An introduction to sending, receiving, and managing email conversations with Inboxes.

Resend provides all the tools you need to host email inboxes on your [verified domains](/docs/dashboard/domains/introduction). Create an inbox to manage conversation threads for a single email address, such as a dedicated address for support emails.

Inboxes are useful for:

* AI agent email.
* Support and triage for contact forms.
* Shared team inboxes.
* Replies for transactional email.

## How Inboxes work

Inboxes mirror the familiar email inbox structure, using [**threads**](/docs/guides/inboxes/threads), [**labels**](/docs/guides/inboxes/labels), and [**drafts**](/docs/guides/inboxes/drafts) to organize your conversations. `inbox`, `sent`, `archive`, `trash`, and `spam` folders are built in to your Resend Inbox.

> [!NOTE]
>
> Receiving email in an inbox is different from [receiving
> emails](/docs/dashboard/receiving/introduction), which delivers inbound messages
> for a domain to your own webhook endpoint. Use Inboxes when you want Resend to
> store, thread, and organize conversations for you.

All of this is available through the dashboard, the API, the CLI, and the MCP server. You can use the dashboard with your team, build your own experience upon the API, and provide inboxes to AI agents.

## Inboxes features

With Resend Inboxes you can:

* Draft and send new emails from a dedicated email address that users can reply to.
* Receive inbound emails and attachments and reply to them in a threaded conversation.
* Forward received emails to another email address.
* Read threads, and move them between `inbox`, `archive`, `spam` or `trash` folders.
* Assign threads to teammates.
* Organize threads with custom labels.
* Search and filter threads.
* Configure an agent to perform actions on inbound mail.
* Receive webhooks for inbox events.

## Prerequisites

* A [verified domain with receiving enabled](/docs/dashboard/receiving/custom-domains). If you are unable to configure your custom domain to receive email, then you must configure [Inbox forwarding](/docs/guides/inboxes/create-inboxes#forward-an-existing-address) when you create your Inbox.

## Quickstart

Create an Inbox in the [Inboxes Dashboard](https://resend.com/inboxes). Or, get started with the [Inboxes API](/docs/api-reference/inboxes/create-inbox) and [SDKs](/docs/sdks), [CLI commands](/docs/cli#inboxes), or [MCP server](/docs/mcp-server).

To create an inbox in the Dashboard:

**1. Navigate to the Inboxes Dashboard page.**

**2. Select **Create inbox**.**

**3. Enter the address.**

**4. Choose the domain from your list of verified domains.**

**5. Send a test email to the new address.**

From any email account, send a message to the inbox address. It appears in
the **Inbox** folder as a new thread within a few seconds.

**6. Open the thread and reply.**

Select the thread, click **Reply**, write your message, and click **Send**.
The reply goes out from the inbox address and stays in the same thread.

## Related Guides

> [card] [Create inboxes](/docs/guides/inboxes/create-inboxes)
>
> Create an address on a verified domain, or forward an existing address.

> [card] [Manage inboxes](/docs/guides/inboxes/manage-inboxes)
>
> Rename, update, and delete inboxes.

> [card] [Manage threads](/docs/guides/inboxes/threads)
>
> Read, search, and organize conversations, and reply to or forward emails.

> [card] [Drafts](/docs/guides/inboxes/drafts)
>
> Write a message now and send it later.

> [card] [Labels](/docs/guides/inboxes/labels)
>
> Tag threads with colored labels to keep them organized.

> [card] [Inbox agent](/docs/guides/inboxes/agent)
>
> Let the built-in agent triage incoming threads from your instructions.

> [card] [Build a support inbox](/docs/guides/inboxes/build-a-support-inbox)
>
> Send contact form submissions to an inbox that the agent triages.


# Introduction
Source: https://resend.com/docs/dashboard/logs/introduction

Learn how to view and troubleshoot API logs.

## Overview

Logs are a powerful tool for monitoring activity and troubleshooting issues.

> [tab] Using the dashboard
>
> Access your logs from the [Logs page](https://resend.com/logs) in the dashboard.
>
> ![Logs](https://mintcdn.com/resend/jNLP19MmH13tZf-I/images/logs-page.png?fit=max\&auto=format\&n=jNLP19MmH13tZf-I\&q=85\&s=c6255bb12281961d20606de92a778b99)
>
> Each log entry shows:
>
> * **Endpoint** - The API endpoint called (e.g., `/domains`, `/api-keys`, `/contacts`)
> * **Status** - The HTTP response status code (200, 201, etc.)
> * **Method** - The HTTP method used (GET, POST, DELETE, etc.)
> * **Created** - When the request was made (displayed as relative time)
>
> ## Searching Logs
>
> Use the search bar to find specific logs. This is useful when tracking down a particular request or debugging an issue.
>
> ## Filtering Logs
>
> Filter logs by response status to quickly identify issues:
>
> * **All Statuses** - View all logs
> * **Successes** - Show only successful requests (2xx status codes)
> * **Errors** - Show only failed requests (4xx and 5xx status codes)
> * **Specific codes** - Select one or more specific HTTP status codes (200, 201, 403, 429, etc.)
>
> You can select multiple status codes to create custom filters.
>
> * **Date range** - Adjust the time period for logs (e.g., Last 15 days)
> * **User Agents** - Filter by SDK or client
> * **API Keys** - Filter by specific API key
>
> ## Log details
>
> Click any log entry to view complete details.
>
> ![Logs](https://mintcdn.com/resend/jNLP19MmH13tZf-I/images/logs-page-details.png?fit=max\&auto=format\&n=jNLP19MmH13tZf-I\&q=85\&s=dd6d948f384d6b90e8a5bed33ec237f0)
>
> ### Request information
>
> * **Request body** - The full JSON payload sent to the API (with copyable code blocks)
> * **HTTP method** - GET, POST, etc.
> * **Endpoint** - The API endpoint called
> * **User-Agent** - The client or SDK used, with automatic SDK detection showing name and version
>
> ### Response information
>
> * **Response body** - The complete API response (with copyable code blocks)
> * **Status code** - The HTTP status code returned
> * **Timestamp** - When the request was processed
>
> ### Related emails
>
> When a log entry is associated with one or more email sends, an Email field appears in the log details, linking directly to the corresponding email records. The corresponding email's detail page includes a Log field linking to the API request log that triggered it, so you can trace the full request-to-delivery flow in both directions.
>
> ### SDK detection
>
> The dashboard automatically detects and displays Resend SDK information from the User-Agent header, showing:
>
> * SDK name (e.g., "Resend Node.js")
> * Version number
> * Update notification when a newer SDK version is available
>
> ## Troubleshooting errors
>
> For supported error types, click the **Help me fix** button to open a troubleshooting drawer.
>
> ![Logs](https://mintcdn.com/resend/jNLP19MmH13tZf-I/images/logs-page-error.png?fit=max\&auto=format\&n=jNLP19MmH13tZf-I\&q=85\&s=60e6190acbb51c2d97a08f0bac177d74)
>
> The drawer includes:
>
> * **Raw response** - The complete API response
> * **Detailed guidance** - Step-by-step instructions to resolve the issue
> * **Relevant links** - Documentation and knowledge base articles
> * **Contextual information** - Your current rate limits, verified domains, and other relevant data
>
> ## Copy for AI
>
> For error logs (4xx and 5xx status codes), use the **Copy for AI** dropdown to get help debugging:
>
> * **Copy log** - Copy the log details as Markdown formatted for AI tools
> * **Open in ChatGPT** - Open ChatGPT with the log prefilled for analysis
> * **Open in Claude** - Open Claude with the log prefilled for analysis
>
> The copied content includes the request method, endpoint, request body, response status, and response body to help AI assistants understand and troubleshoot the issue.

> [tab] Using the API
>
> The Logs API allows you to **programmatically retrieve logs**. This is useful for integrating with your own systems, automating tasks, and equipping your AI agents with the ability to troubleshoot issues.
>
> ## List logs
>
> Retrieve a list of API request logs.
>
> The response includes details such as:
>
> * The **endpoint** called
> * The response **status code**
> * The **user agent**
>
> ```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.logs.list();
> ```
>
> ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->logs->list();
> ```
>
> ```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> resend.Logs.list()
> ```
>
> ```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> logs = Resend::Logs.list
> puts logs
> ```
>
> ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import (
>   "context"
>
>   "github.com/resend/resend-go/v4"
> )
>
> func main() {
>   ctx := context.TODO()
>   client := resend.NewClient("re_xxxxxxxxx")
>
>   logs, err := client.Logs.ListWithOptions(ctx, nil)
>   if err != nil {
>     panic(err)
>   }
>
>   if logs.HasMore {
>     opts := &resend.ListOptions{
>       After: &logs.Data[len(logs.Data)-1].Id,
>     }
>     client.Logs.ListWithOptions(ctx, opts)
>   }
> }
> ```
>
> ```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{Resend, Result, list_opts::ListOptions};
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let _logs = resend
>     .logs
>     .list(ListOptions::default())
>     .await?;
>
>   Ok(())
> }
> ```
>
> ```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         resend.logs().list();
>     }
> }
> ```
>
> ```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
> // C# SDK is not available yet
> ```
>
> ```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X GET 'https://api.resend.com/logs' \
>     -H 'Authorization: Bearer re_xxxxxxxxx'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend logs list
> ```
>
> ## Retrieve log
>
> Once you're ready to inspect a log in greater detail, you can use the [Retrieve Log](/docs/api-reference/logs/retrieve-log) endpoint.
>
> This endpoint returns the full request body and response, as well as the endpoint, status code, and user agent.
>
> ```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
> import { Resend } from 'resend';
>
> const resend = new Resend('re_xxxxxxxxx');
>
> const { data, error } = await resend.logs.get(
>   '37e4414c-5e25-4dbc-a071-43552a4bd53b',
> );
> ```
>
> ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
> $resend = Resend::client('re_xxxxxxxxx');
>
> $resend->logs->get('37e4414c-5e25-4dbc-a071-43552a4bd53b');
> ```
>
> ```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
> import resend
>
> resend.api_key = "re_xxxxxxxxx"
>
> resend.Logs.get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
> ```
>
> ```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
> require "resend"
>
> Resend.api_key = "re_xxxxxxxxx"
>
> log = Resend::Logs.get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
> puts log
> ```
>
> ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
> package main
>
> import "github.com/resend/resend-go/v4"
>
> func main() {
>   client := resend.NewClient("re_xxxxxxxxx")
>
>   client.Logs.Get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
> }
> ```
>
> ```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
> use resend_rs::{Resend, Result};
>
> #[tokio::main]
> async fn main() -> Result<()> {
>   let resend = Resend::new("re_xxxxxxxxx");
>
>   let _logs = resend
>     .logs
>     .get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
>     .await?;
>
>   Ok(())
> }
> ```
>
> ```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
> import com.resend.*;
> import com.resend.core.exception.ResendException;
>
> public class Main {
>     public static void main(String[] args) throws ResendException {
>         Resend resend = new Resend("re_xxxxxxxxx");
>
>         resend.logs().get("37e4414c-5e25-4dbc-a071-43552a4bd53b");
>     }
> }
> ```
>
> ```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
> // C# SDK is not available yet
> ```
>
> ```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -X GET 'https://api.resend.com/logs/37e4414c-5e25-4dbc-a071-43552a4bd53b' \
>     -H 'Authorization: Bearer re_xxxxxxxxx'
> ```
>
> ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
> resend logs get 37e4414c-5e25-4dbc-a071-43552a4bd53b
> ```

***

> [!NOTE]
>
> View a comprehensive list of error codes and their meanings in the [Resend API
> Reference](/docs/api-reference/errors).

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

> [!NOTE]
>
> Currently, exports are limited to admin users of your team.

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

> [!NOTE]
>
> All exports your team creates are listed in the
> [Exports](https://resend.com/exports) page under **Settings** > **Team** >
> **Exports**. Select any export to view its details page. All members of your
> team can view your exports, but only admins can download the data.


# Process Receiving Attachments
Source: https://resend.com/docs/dashboard/receiving/attachments

Process attachments from receiving emails.

A common use case for Receiving emails is to process attachments.

You can access received email attachments in two ways:

* [View and download from the dashboard](#view-and-download-attachments) to inspect a single email.
* [Use the Attachments API](#process-attachments-programmatically) to process attachments programmatically.

## View and download attachments

You can view and download attachments directly from the dashboard when inspecting a received email.

1. Go to [Emails](https://resend.com/emails) and select the **Receiving** tab.
2. Open the received email that includes the attachment.
3. Click the attachment to download it locally.

For automated processing, use the [Attachments API](#process-attachments-programmatically) instead.

## Process attachments programmatically

> [!NOTE]
>
> Webhooks do not include the actual content of attachments, only their
> metadata. You must call the [Attachments
> API](/docs/api-reference/emails/list-received-email-attachments) to retrieve the
> content. This design choice supports large attachments in serverless
> environments that have limited request body sizes.

Users can forward airplane tickets, receipts, and expenses to you. Then, you can extract key information from attachments and use that data.

To do this, call the [Attachments API](/docs/api-reference/emails/list-received-email-attachments) after receiving the webhook event. That API will return a list of attachments with their metadata and a `download_url` that you can use to download the actual content. To retrieve a single attachment, use [Retrieve Attachment](/docs/api-reference/emails/retrieve-received-email-attachment).

Note that the `download_url` is valid for 1 hour. After that, you will need to call the
[Attachments API](/docs/api-reference/emails/list-received-email-attachments)
again to get a new `download_url`. You can also check the `expires_at` field on
each attachment to see exactly when it will expire.

Here's how you can implement this:

```ts Next.js theme={"theme":{"light":"github-light","dark":"vesper"}}
// app/api/events/route.ts
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    const { data: attachments, error } =
      await resend.emails.receiving.attachments.list({
        emailId: event.data.email_id,
      });

    if (error) {
      return NextResponse.json({ error: error.message }, { status: 500 });
    }

    for (const attachment of attachments.data) {
      // use the download_url to download attachments however you want
      const response = await fetch(attachment.download_url);
      if (!response.ok) {
        console.error(`Failed to download ${attachment.filename}`);
        continue;
      }

      // get the file's contents
      const buffer = Buffer.from(await response.arrayBuffer());

      // process the content (e.g., save to storage, analyze, etc.)
    }

    return NextResponse.json({
      attachmentsProcessed: attachments.data.length,
    });
  }

  return NextResponse.json({});
};
```

```php Laravel theme={"theme":{"light":"github-light","dark":"vesper"}}
// routes/api.php
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Route;
use Resend\Laravel\Facades\Resend;

Route::post('/events', function (Request $request) {
  $event = $request->json()->all();

    if ($event['type'] === 'email.received') {
        $attachments = Resend::emails()->receiving->attachments->list(
            emailId: $event['data']['email_id']
        );

        foreach ($attachments->data as $attachment) {
            $response = Http::get($attachment->download_url);

            if ($response->failed()) {
                Log::error("Failed to download {$attachment->filename}");
                continue;
            }

            // get the file's contents
            $contents = $response->body();

            // process the content (e.g., save to storage, analyze, etc.)
        }

        return new JsonResponse($event);
    }

    return new JsonResponse([]);
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
// index.php
// Include Composer autoload file to load Resend SDK classes...
require __DIR__ . '/vendor/autoload.php';

header('Content-Type: application/json');

if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    http_response_code(405);
    echo json_encode(['error' => 'Method Not Allowed']);
    exit;
}

$body = file_get_contents('php://input');
$event = json_decode($body, true);

if (json_last_error() !== JSON_ERROR_NONE) {
    http_response_code(400);
    echo json_encode(['error' => 'Invalid JSON']);
    exit;
}

if ($event['type'] === 'email.received') {
    $resend = Resend::client('re_xxxxxxxxx');

    $attachments = $resend->emails->receiving->attachments->list(
        emailId: $event['data']['email_id']
    );

    foreach ($attachments->data as $attachment) {
        $ch = curl_init($attachment->download_url);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_FOLLOWLOCATION => true,
        ]);

        $contents = curl_exec($ch);
        $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $ch = null;

        if ($contents === false || $statusCode !== 200) {
            error_log("Failed to download {$attachment->filename}");
            continue;
        }

        // process the content (e.g., save to disk, analyze, etc.)
    }

    echo json_encode($event);
    exit;
}

echo json_encode([]);
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use axum::{
    extract::State,
    response::{IntoResponse, Json, Response},
};
use resend_rs::{json, list_opts::ListOptions, Resend};
use serde::Serialize;
use std::sync::Arc;

struct AppState {
    resend: Resend,
}

#[derive(Serialize)]
struct Empty {}

async fn example(
    State(state): State<Arc<AppState>>,
    Json(event): Json<resend_rs::events::EmailEvent>,
) -> Response {
    if matches!(
        event.r#type,
        resend_rs::events::EmailEventType::EmailReceived
    ) {
        let attachments = state
            .resend
            .receiving
            .list_attachments(&event.data.email_id, ListOptions::default())
            .await
            .unwrap();

        for attachment in &attachments.data {
            // use the download_url to download attachments however you want
            let response = reqwest::get(&attachment.download_url).await;

            if response.is_err() {
                dbg!(format!(
                    "Failed to download {}",
                    attachment.filename.clone().unwrap()
                ));
            }

            // get the file's contents
            let _buffer = response.unwrap().bytes().await.unwrap();

            // process the content (e.g., save to storage, analyze, etc.)
        }

        Json(json!({
            "attachmentsProcessed": attachments.len()
        }))
        .into_response()
    } else {
        Json(Empty {}).into_response()
    }
}
```

Once you process attachments, you may want to forward the email to another address. Learn more about [forwarding emails](/docs/dashboard/receiving/forward-emails).


# Create a receiving Webhook
Source: https://resend.com/docs/dashboard/receiving/create-receiving-webhook

Learn how to create a webhook to respond to received emails with Resend.

## Configure Webhook

Once you can [receive emails](/docs/dashboard/receiving/introduction#quickstart), you can create a route to handle these emails in your application and configure an [`email.received` webhook](/docs/webhooks/emails/received) in your Dashboard.

Alternatively, you can use Resend's code tools to create your webhook from the [Webhooks API](/docs/api-reference/webhooks/create-webhook) or with a [webhook CLI command](/docs/cli#webhooks).

To configure your webhook in the Dashboard:

**1. Create a route to receive emails.**

In your application, create a new route that can accept `POST` requests.

Here's how you can implement this:

```js Next.js theme={"theme":{"light":"github-light","dark":"vesper"}}
// app/api/events/route.ts
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    return NextResponse.json(event);
  }

  return NextResponse.json({});
};
```

```php Laravel theme={"theme":{"light":"github-light","dark":"vesper"}}
// routes/api.php
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;

Route::post('/events', function (Request $request) {
    $event = $request->json()->all();

    if ($event['type'] === 'email.received') {
        return response()->json($event);
    }

    return response()->json([]);
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
// index.php
header('Content-Type: application/json');

if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    http_response_code(405);
    echo json_encode(['error' => 'Method Not Allowed']);
    exit;
}

$body = file_get_contents('php://input');
$event = json_decode($body, true);

if (json_last_error() !== JSON_ERROR_NONE) {
    http_response_code(400);
    echo json_encode(['error' => 'Invalid JSON']);
    exit;
}

if ($event['type'] === 'email.received') {
    echo json_encode($event);
    exit;
}

echo json_encode([]);
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
#[derive(Serialize)]
struct Empty {}

async fn example(Json(event): Json<resend_rs::events::EmailEvent>) -> Response {
    if matches!(
        event.r#type,
        resend_rs::events::EmailEventType::EmailReceived
    ) {
        Json(event).into_response()
    } else {
        Json(Empty {}).into_response()
    }
}
```

Once you receive the email event, you can process the email body and attachments. You can also implement [webhook request verification](/docs/webhooks/verify-webhooks-requests) to secure your webhook endpoint.

> [!TIP]
>
> Any email sent to any username at your receiving domain will be received
> by Resend and forwarded to your webhook. You can intelligently route based
> on the `to` field in the webhook event to create different workflows to
> handle different inbound emails.

**2. Go to the Webhooks page in your Resend Dashboard**

**3. Click Add Webhook.**

**4. Enter the URL of the route you created for your webhook endpoint.**

**5. Select the event type `email.received`.**

![Add Webhook for Receiving Emails](https://mintcdn.com/resend/1QlhxulUFE6jxYM_/images/inbound-webhook-setup.jpg?fit=max\&auto=format\&n=1QlhxulUFE6jxYM_\&q=85\&s=55ae3e35788d91065d59ff4ddebff7e6)

**6. Click Add.**

> [!TIP]
>
> For development, you can create a tunnel to your localhost server using a tool like
> [ngrok](https://ngrok.com/download) or [VS Code Port Forwarding](https://code.visualstudio.com/docs/debugtest/port-forwarding). These tools serve your local dev environment at a public URL you can use to test your local webhook endpoint.
>
> Example: `https://example123.ngrok.io/api/webhook`

Once you receive an email event, you can process the email body and attachments from the webhook payload.

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.received",
  "created_at": "2026-02-22T23:41:12.126Z",
  "data": {
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "created_at": "2026-02-22T23:41:11.894Z",
    "from": "onboarding@resend.dev",
    "to": ["delivered@resend.dev"],
    "bcc": [],
    "cc": [],
    "received_for": ["forwarded@example.com"],
    "message_id": "<111-222-333@email.example.com>",
    "subject": "Sending this example",
    "attachments": [
      {
        "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
        "filename": "avatar.png",
        "content_type": "image/png",
        "content_disposition": "inline",
        "content_id": "img001"
      }
    ]
  }
}
```

> [!NOTE]
>
> Webhooks do not include the email body, headers, or attachments, only their
> metadata. You must call the [Received emails
> API](/docs/api-reference/emails/retrieve-received-email) or the [Attachments
> API](/docs/api-reference/emails/list-received-email-attachments) to retrieve them.
> This design choice supports large attachments in serverless environments that
> have limited request body sizes.

## API Reference

For complete API documentation, see the [Webhooks API reference](/docs/api-reference/webhooks/create-webhook).


# Custom Receiving Domains
Source: https://resend.com/docs/dashboard/receiving/custom-domains

Receive emails using your own domain.

In addition to [using Resend-managed domains](/docs/dashboard/receiving/introduction#quickstart), you can also receive emails using your own custom domain.

## Enabling receiving for a new domain

Receiving emails requires an extra [MX record](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records) to work. You'll need to add this record to your DNS provider.

**1. Verify your domain**

If you have not already done so, [add and verify your
domain](/docs/add-a-domain).

**2. Navigate to the Domains page in your Dashboard**

**3. Copy the MX record**

**4. Paste the MX record into your domain's DNS service**

![Add DNS records for Receiving Emails](https://mintcdn.com/resend/1QlhxulUFE6jxYM_/images/inbound-custom-domain-dns.jpg?fit=max\&auto=format\&n=1QlhxulUFE6jxYM_\&q=85\&s=0bb3258dbd1e9fc5efeb9ead53b219a2)

> [!WARNING]
>
> If you already have existing MX records for your domain (because you're already
> using it for a real inbox, for example), we recommend that you
> create a subdomain (e.g. `subdomain.example.com`) and add the MX record
> there. This way, you can use Resend for receiving emails without affecting
> your existing email service. Note that you will *not* receive emails at Resend
> if the required `MX` record is not the lowest priority value for the domain.
>
> Alternatively, you can configure your email service to forward emails to an address
> on a domain where receiving is verified in Resend. Don't forward directly to the
> SMTP server address that appears in the receiving `MX` record: Resend drops emails
> for domains whose receiving `MX` record isn't verified.

You can now [create a webhook to receive emails](/docs/dashboard/receiving/create-receiving-webhook) at your custom domain in your application.

## Enabling receiving for an existing domain

If you already have a verified domain, you can enable receiving by using the toggle in the receiving section of the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/cxinN79qDVOa7Vo6/images/inbound-enable-receiving.jpg?fit=max\&auto=format\&n=cxinN79qDVOa7Vo6\&q=85\&s=43ea9fce84b46236ce4d58efc6004a24)

After enabling receiving, you'll see a modal showing the MX record that you need to add to your DNS provider to start receiving emails.

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Once you add the MX record, confirm by clicking the **I've added the record** button and wait for the receiving record to show as "verified".

## FAQ

> [accordion] What happens if I already have MX records for my domain?
>
> If you already have existing MX records for your domain, we recommend that you
> create a subdomain (e.g. `subdomain.example.com`) and add the MX record
> there.
>
> That's because emails will usually only be delivered to the MX record with the lowest
> priority value. Therefore, if you add Resend's MX record to your root domain alongside existing MX records,
> it will either not receive any emails at all (if the existing MX records have a lower priority),
> or it will interfere with your existing email service (if Resend's MX record has a lower priority). If you
> use the same priority, email delivery will be unpredictable and may hit either Resend or your existing email
> service.
>
> If you still want to use the same domain both in for Resend and your day-to-day
> email service, you can also set up forwarding rules in your existing email service
> to forward emails to an address on a domain where receiving is verified in Resend.
> Forwarding directly to the SMTP server address that appears in the receiving `MX`
> record doesn't work: Resend drops emails for domains whose receiving `MX` record
> isn't verified.

> [accordion] I have already verified my domain for sending. Do I need to verify it again for receiving?
>
> No, you do not need to verify your entire domain again. If you already have a
> verified domain for sending, you can simply enable receiving for that domain,
> add the required MX record to your DNS provider, and click "I've added the record"
> to start verifying *only* the MX record.

> [accordion] I want my domain to only receive emails, not send emails from Resend. Is that possible?
>
> Yes, on the domain details page, turn off "Enable Sending". You no longer need Resend's SPF records, so you can remove them from your DNS host. You still need our DKIM record to stay published, and the receiving `MX` record with "Enable Receiving" turned on.


# Forward Received Emails
Source: https://resend.com/docs/dashboard/receiving/forward-emails

Forward Received emails to another email address.

Received emails can also be forwarded to another email address.

> [!NOTE]
>
> Webhooks do not include the email body, headers, or attachments, only their
> metadata. You must call the [Received emails
> API](/docs/api-reference/emails/retrieve-received-email) or the [Attachments
> API](/docs/api-reference/emails/list-received-email-attachments) to retrieve them.
> This design choice supports large attachments in serverless environments that
> have limited request body sizes.

## Using the `forward` helper method

The Node.js SDK provides a `forward()` helper method that simplifies forwarding received emails. This method automatically handles fetching the email content and attachments.

Here's how you can implement this:

```ts Next.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    const { data, error } = await resend.emails.receiving.forward({
      emailId: event.data.email_id,
      to: 'delivered@resend.dev',
      from: 'onboarding@resend.dev',
    });

    if (error) {
      return new NextResponse(`Error: ${error.message}`, { status: 500 });
    }

    return NextResponse.json(data);
  }

  return NextResponse.json({});
};
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use axum::{
    extract::State,
    http::StatusCode,
    response::{IntoResponse, Json, Response},
};
use resend_rs::{
    types::{ForwardReceivingEmail, InboundEmailId},
    Resend,
};
use serde::Serialize;
use std::sync::Arc;

struct AppState {
    resend: Resend,
}

#[derive(Serialize)]
struct Empty {}

async fn example(
    State(state): State<Arc<AppState>>,
    Json(event): Json<resend_rs::events::EmailEvent>,
) -> Result<Response, Response> {
    if matches!(
        event.r#type,
        resend_rs::events::EmailEventType::EmailReceived
    ) {
        let opts = ForwardReceivingEmail::new(
            InboundEmailId::new(&event.data.email_id),
            "onboarding@resend.dev",
            vec!["delivered@resend.dev"],
        );
        let data = state.resend.receiving.forward(opts).await.map_err(|e| {
            (StatusCode::INTERNAL_SERVER_ERROR, format!("Error: {}", e)).into_response()
        })?;
        Ok(Json(data).into_response())
    } else {
        Ok(Json(Empty {}).into_response())
    }
}
```

By default, the `forward` method forwards the email in a way that preserves the original email content and attachments exactly as received.

Alternatively, you can forward emails as if they had been forwarded through an email client, with the `forwarded message` footer. For that, use `passthrough: false` and provide custom text or HTML content. The original email will be shown after the `forwarded message` footer:

```ts Next.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend, type EmailReceivedEvent } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export async function forwardEmail(event: EmailReceivedEvent) {
  const { data, error } = await resend.emails.receiving.forward({
    emailId: event.data.email_id,
    to: 'delivered@resend.dev',
    from: 'onboarding@resend.dev',
    passthrough: false,
    text: 'See attached forwarded message.',
    html: '<p>See attached forwarded message.</p>',
  });
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
    events::EmailEvent,
    types::{ForwardReceivingEmail, InboundEmailId},
    Resend,
};

async fn forward(resend: &Resend, event: EmailEvent) {
    let opts = ForwardReceivingEmail::new(
        InboundEmailId::new(&event.data.email_id),
        "onboarding@resend.dev",
        vec!["delivered@resend.dev"],
    )
    .with_passthrough(false)
    .with_text("See attached forwarded message.")
    .with_html("<p>See attached forwarded message.</p>");

    let data = resend.receiving.forward(opts).await;
}
```

## Manual forwarding

If you're not using Node.js or prefer not to use the `forward` helper method, you can manually forward received emails using the [Send Email API](/docs/api-reference/emails/send-email).

The recommended approach is to download the raw email and parse it to properly extract content and attachments (especially for inline images). Then, you can send a new email with the extracted content and attachments using the [Send Email API](/docs/api-reference/emails/send-email).

```js app/api/events/route.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend } from 'resend';
import { simpleParser } from 'mailparser';

const resend = new Resend('re_xxxxxxxxx');

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    // Get the email metadata
    const { data: email } = await resend
      .emails
      .receiving
      .get(event.data.email_id);

    // Download the raw email content if available
    if (!email?.raw?.download_url) {
      return new NextResponse('Raw email not available', { status: 500 });
    }

    const rawResponse = await fetch(email.raw.download_url);
    const rawEmailContent = await rawResponse.text();

    // Parse the raw email to extract content and attachments
    const parsed = await simpleParser(rawEmailContent, {
      skipImageLinks: true,
    });

    // Extract attachments with content_id for inline images
    const attachments = parsed.attachments.map((attachment) => {
      // Strip < and > from content IDs for proper inline image handling
      const contentId = attachment.contentId
        ? attachment.contentId.replace(/^<|>$/g, '')
        : undefined;

      return {
        filename: attachment.filename,
        content: attachment.content.toString('base64'),
        contentType: attachment.contentType,
        contentId: contentId || undefined,
      };
    });

    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: email.subject || '(no subject)',
      html: parsed.html || undefined,
      text: parsed.text || '',
      attachments: attachments.length > 0 ? attachments : undefined,
    });

    if (error) {
      return new NextResponse(`Error: ${error.message}`, { status: 500 });
    }

    return NextResponse.json(data);
  }

  return NextResponse.json({});
};
```

> [!NOTE]
>
> This example uses the [`mailparser`](https://www.npmjs.com/package/mailparser)
> library (`npm install mailparser`) to parse the raw email. For other
> languages/SDKs, you'll need an equivalent email parsing library capable of
> processing emails compliant to [RFC
> 5322](https://datatracker.ietf.org/doc/html/rfc5322).


# Get Email Content
Source: https://resend.com/docs/dashboard/receiving/get-email-content

Get the body and headers of a received email.

Receiving emails contain the HTML and Plain Text body of the email, as well as the headers.

> [!NOTE]
>
> Webhooks do not include the email body, headers, or attachments, only their
> metadata. You must call the [Received emails
> API](/docs/api-reference/emails/retrieve-received-email) or the [Attachments
> API](/docs/api-reference/emails/list-received-email-attachments) to retrieve them.
> This design choice supports large attachments in serverless environments that
> have limited request body sizes.

After receiving the webhook event, call the [Receiving API](/docs/api-reference/emails/retrieve-received-email).

Here are some examples:

```ts Next.js theme={"theme":{"light":"github-light","dark":"vesper"}}
// app/api/events/route.ts
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    const { data: email } = await resend.emails.receiving.get(
      event.data.email_id,
    );

    if (!email) {
      return NextResponse.json({ error: 'Email not found' }, { status: 404 });
    }

    console.log(email.html);
    console.log(email.text);
    console.log(email.headers);

    return NextResponse.json(email);
  }

  return NextResponse.json({});
};
```

```php Laravel theme={"theme":{"light":"github-light","dark":"vesper"}}
// routes/api.php
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Route;
use Resend\Laravel\Facades\Resend;

Route::post('/events', function (Request $request) {
    $event = $request->json()->all();

    if ($event['type'] === 'email.received') {
        $email = Resend::emails()->receiving->get($event['data']['email_id']);

        Log::info($email->html);
        Log::info($email->text);
        Log::info(print_r($email->headers, true));

        return new JsonResponse($email);
    }

    return new JsonResponse([]);
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
// index.php
// Include Composer autoload file to load Resend SDK classes...
require __DIR__ . '/vendor/autoload.php';

header('Content-Type: application/json');

if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
    http_response_code(405);
    echo json_encode(['error' => 'Method Not Allowed']);
    exit;
}

$body = file_get_contents('php://input');
$event = json_decode($body, true);

if (json_last_error() !== JSON_ERROR_NONE) {
    http_response_code(400);
    echo json_encode(['error' => 'Invalid JSON']);
    exit;
}

if ($event['type'] === 'email.received') {
    $resend = Resend::client('re_xxxxxxxxx');

    $email = $resend->emails->receiving->get($event['data']['email_id']);

    echo json_encode($email);
    exit;
}

echo json_encode([]);
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use axum::{
    extract::State,
    response::{IntoResponse, Json, Response},
};
use resend_rs::{types::GetInboundEmailOptions, Resend};
use serde::Serialize;
use std::sync::Arc;

struct AppState {
    resend: Resend,
}

#[derive(Serialize)]
struct Empty {}

async fn example(
    State(state): State<Arc<AppState>>,
    Json(event): Json<resend_rs::events::EmailEvent>,
) -> Response {
    if matches!(
        event.r#type,
        resend_rs::events::EmailEventType::EmailReceived
    ) {
        let email = state
            .resend
            .receiving
            .get(&event.data.email_id, GetInboundEmailOptions::default())
            .await
            .unwrap();

        dbg!(&email.html, &email.text, &email.headers);

        Json(email).into_response()
    } else {
        Json(Empty {}).into_response()
    }
}
```


# Receiving Emails
Source: https://resend.com/docs/dashboard/receiving/introduction

An introduction to receiving emails with Resend.

## Receiving emails through Resend

Resend provides all the tools you need to receive emails (commonly called inbound) at [a verified domain](/docs/dashboard/domains/introduction), or at your account's Resend-managed `<id>.resend.app` subdomain.

This is useful for:

* Receiving support emails from users.
* Processing forwarded attachments.
* Replying to emails from customers.

## Receiving features

With Resend's email receiving features, you can:

* View all received emails in the [**Emails** Dashboard page](https://resend.com/emails).
* Receive incoming emails and [get notified with a webhook](/docs/dashboard/receiving/create-receiving-webhook) event.
* [Poll for new inbound emails in the terminal](/docs/cli#receiving) and display them as they arrive.
* [Retrieve full email content](/docs/dashboard/receiving/get-email-content) (HTML, text, headers) for use in your application.
* [Process attachments](/docs/dashboard/receiving/attachments) using attachment metadata and temporary download URLs.
* [Forward emails](/docs/dashboard/receiving/forward-emails) to another email address.
* [Reply to emails](/docs/dashboard/receiving/reply-to-emails) in the same thread
* [View API endpoint logs](/docs/dashboard/logs/introduction) and deliverability metrics for monitoring and troubleshooting.

## Quickstart

To start receiving emails using a domain managed by Resend, get your unique `<id>.resend.app` domain:

**1. Go to the Emails page in your Resend dashboard.**

**2. Select the Receiving tab.**

**3. Get your custom Resend domain.**

Click the three dots button and select Receiving address to see your custom Resend subdomain.

![Get your Resend domain](https://mintcdn.com/resend/stmz8SfTchQy1hpq/images/inbound-resend-domain.jpg?fit=max\&auto=format\&n=stmz8SfTchQy1hpq\&q=85\&s=c26fcec3f9dc5def25041d44cb8c501a)

**4. Send yourself a test email.**

Send an email to any username at your subdomain (e.g., `test@<id>.resend.app`). You will receive emails sent to any address at your Resend domain.

**5. View your received email in the Receiving tab of the Emails Dashboard page.**

You can also [configure a verified domain for receiving emails](/docs/dashboard/receiving/custom-domains) at your custom domain. Once you add the MX record to your custom domain, you will receive emails through Resend for any address at that domain.

## Configure Webhook

Once you can receive mail, you can [create a received mail webhook](/docs/dashboard/receiving/create-receiving-webhook) to receive real-time notifications about incoming email.

Resend processes all incoming emails to your receiving domain, parses the contents and attachments, and then sends a `POST` request to an endpoint that you choose to handle the received email.

![Receiving email process](https://mintcdn.com/resend/bxWCBKtofKnXvbvf/images/receiving-emails.jpeg?fit=max\&auto=format\&n=bxWCBKtofKnXvbvf\&q=85\&s=faa9d79f48a43f320d2b5a800256060e)

## Choose your infrastructure

To handle your received emails, you can use a variety of tools:

* [SDK](/docs/sdks): process inbound emails with an SDK built for your language
* [Integrations](/docs/integrations): process inbound emails using a framework or tool you already use
* [API](/docs/api-reference/emails/retrieve-received-email): process inbound emails with raw HTTP API calls
* [CLI](/docs/cli#receiving): process inbound emails and stream incoming messages from the terminal
* [MCP](/docs/mcp-server): list, read, and download inbound emails through your agent with MCP

See how to use all of Resend's receiving features such as processing attachments and forwarding emails to another address in the [receiving email guides](#related-guides).

## Manage your received emails

After you've received your first email, you'll be able to view and manage your emails in the [Emails Dashboard page](https://resend.com/emails) under the Receiving tab. From here, you can view email details, share a public version, and more.

You can also manage your emails programmatically using the [Receiving API](/docs/api-reference/emails/retrieve-received-email), [CLI commands](/docs/cli#receiving), or the [MCP server](/docs/mcp-server).

Learn more about [managing your received emails](/docs/dashboard/receiving/manage-emails) in the dedicated guide.

## Related Guides

See how to use Resend's receiving features.

> [card] [Custom domains](/docs/dashboard/receiving/custom-domains)

> [card] [Received email webhook](/docs/dashboard/receiving/create-receiving-webhook)

> [card] [Get email content](/docs/dashboard/receiving/get-email-content)

> [card] [Process attachments](/docs/dashboard/receiving/attachments)

> [card] [Forward emails](/docs/dashboard/receiving/forward-emails)

> [card] [Threaded replies](/docs/dashboard/receiving/reply-to-emails)

## Examples

> [card] [Next.js (TypeScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/inbound)
>
> See the full source code.

> [card] [Next.js (JavaScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/inbound)
>
> See the full source code.

> [card] [PHP](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/inbound)
>
> See the full source code.

> [card] [Laravel](https://github.com/resend/resend-examples/tree/main/laravel-resend-examples)
>
> See the full source code.

> [card] [Python](https://github.com/resend/resend-examples/tree/main/python-resend-examples/examples)
>
> See the full source code.

> [card] [Ruby](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples)
>
> See the full source code.


# Managing Emails
Source: https://resend.com/docs/dashboard/receiving/manage-emails

An introduction to managing your received emails with Resend.

Your received emails are available in the [**Receiving** tab](https://resend.com/emails/receiving) of the **Emails** Dashboard page.

You can also manage your received emails using the [Receiving API](/docs/api-reference/emails/retrieve-received-email), [MCP server](/docs/mcp-server), and [CLI commands](/docs/cli#receiving) for tasks such as retrieving full email details and attachments.

## View email details

All received emails are stored and available on the [**Emails** Dashboard page](https://resend.com/emails) as they arrive.

In the [**"Receiving"** tab](https://resend.com/emails/receiving), select any email to view its associated metadata. View the sender address, recipient address, subject, unique id, and more. Each email also contains a **Preview**, **Plain Text**, **HTML**, and Raw version to visualize the content of your received email in its various formats.

![Viewing a received email](https://mintcdn.com/resend/JY1SfzW0Yy_MxC1X/images/receiving-manage-emails.png?fit=max\&auto=format\&n=JY1SfzW0Yy_MxC1X\&q=85\&s=9c83e18da72c27630eaf2465800f8967)

If your webhook endpoint is down, you can still replay individual webhook events from the [Webhooks Dashboard page](https://resend.com/webhooks). You can also retrieve your emails at any time using the [Receiving API](/docs/api-reference/emails/retrieve-received-email) and the [receiving CLI commands](/docs/cli#receiving).

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

> [!NOTE]
>
> Currently, exports are limited to admin users of your team.

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

> [!NOTE]
>
> All exports your team creates are listed in the
> [Exports](https://resend.com/exports) page under **Settings** > **Team** >
> **Exports**. Select any export to view its details page. All members of your
> team can view your exports, but only admins can download the data.

## API Reference

For complete API documentation, see the [Receiving API reference](/docs/api-reference/emails/retrieve-received-email).


# Reply to Receiving Emails
Source: https://resend.com/docs/dashboard/receiving/reply-to-emails

Reply to Receiving emails in the same thread.

Email clients thread emails by using the `message_id` metadata.

If you want to reply to an email, add the `In-Reply-To` header set to the `message_id` of the received email. To signal the threading, set the subject to start with `Re:` so that email clients can group the replies together.

## Get the message ID

The `message_id` is included in the [webhook event](/docs/webhooks/emails/received) payload when an email is received:

```json {5} theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.received",
  "data": {
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "message_id": "<111-222-333@email.example.com>",
    "subject": "Sending this example",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"]
  }
}
```

Use the `message_id` value from `event.data.message_id` as the `In-Reply-To` header when sending your reply.

## Send a reply in thread

Here's how you can reply in thread using each SDK:

```ts Node.js {14} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend, type EmailReceivedEvent } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export async function replyToEmail(event: EmailReceivedEvent) {
  const messageId = event.data.message_id;

  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: `Re: ${event.data.subject}`,
    html: '<p>Thanks for your email!</p>',
    headers: {
      'In-Reply-To': messageId,
    },
  });
}
```

```php PHP {13} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$event = json_decode(file_get_contents('php://input'), true);

$messageId = $event['data']['message_id'];

$data = $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => "Re: {$event['data']['subject']}",
    'html' => '<p>Thanks for your email!</p>',
    'headers' => [
        'In-Reply-To' => $messageId,
    ],
]);
```

```python Python {14} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

def handle_email_received(event: resend.EmailReceivedEvent):
    message_id = event["data"]["message_id"]

    params: resend.Emails.SendParams = {
        "from": "Acme <onboarding@resend.dev>",
        "to": ["delivered@resend.dev"],
        "subject": f"Re: {event['data']['subject']}",
        "html": "<p>Thanks for your email!</p>",
        "headers": {
            "In-Reply-To": message_id,
        },
    }

    email = resend.Emails.send(params)
```

```rb Ruby {13} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

message_id = event["data"]["message_id"]

params = {
    from: "Acme <onboarding@resend.dev>",
    to: ["delivered@resend.dev"],
    subject: "Re: #{event['data']['subject']}",
    html: "<p>Thanks for your email!</p>",
    headers: {
        "In-Reply-To": message_id,
    },
}

sent = Resend::Emails.send(params)
```

```go Go {29} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"fmt"
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
    ctx := context.TODO()
    client := resend.NewClient("re_xxxxxxxxx")

    var event struct {
        Data struct {
            MessageId string `json:"message_id"`
            Subject   string `json:"subject"`
        } `json:"data"`
    }

    messageId := event.Data.MessageId

    params := &resend.SendEmailRequest{
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"delivered@resend.dev"},
        Subject: fmt.Sprintf("Re: %s", event.Data.Subject),
        Html:    "<p>Thanks for your email!</p>",
        Headers: map[string]string{
            "In-Reply-To": messageId,
        },
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
        panic(err)
    }
    fmt.Println(sent.Id)
}
```

```rust Rust {17} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::events::EmailEvent;
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

async fn reply(event: EmailEvent) -> Result<()> {
    let resend = Resend::new("re_xxxxxxxxx");

    let message_id = &event.data.message_id;
    let subject = format!("Re: {}", event.data.subject);

    let email = CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        ["delivered@resend.dev"],
        &subject,
    )
    .with_html("<p>Thanks for your email!</p>")
    .with_header("In-Reply-To", message_id);

    let _email = resend.emails.send(email).await?;

    Ok(())
}
```

```java Java {20} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;
import com.resend.services.receiving.model.ReceivedEmail;
import java.util.Map;

public class Main {
    public static void reply(ReceivedEmail event) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        String messageId = event.getMessageId();

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("Re: " + event.getSubject())
                .html("<p>Thanks for your email!</p>")
                .headers(Map.of(
                    "In-Reply-To", messageId
                ))
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {18} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;
using System.Collections.Generic;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

async Task ReplyAsync(ReceivedEmail eventData)
{
    var messageId = eventData.MessageId;

    var message = new EmailMessage()
    {
        From = "Acme <onboarding@resend.dev>",
        To = "delivered@resend.dev",
        Subject = $"Re: {eventData.Subject}",
        HtmlBody = "<p>Thanks for your email!</p>",
        Headers = new Dictionary<string, string>()
        {
            { "In-Reply-To", messageId },
        },
    };

    var resp = await resend.EmailSendAsync(message);
}
```

```bash cURL {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Re: Sending this example",
  "html": "<p>Thanks for your email!</p>",
  "headers": {
    "In-Reply-To": "<111-222-333@email.example.com>"
  }
}'
```

```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Re: Sending this example" \
  --html "<p>Thanks for your email!</p>" \
  --headers "In-Reply-To=<111-222-333@email.example.com>"
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use axum::{
    extract::State,
    response::{IntoResponse, Json, Response},
};
use resend_rs::{types::CreateEmailBaseOptions, Resend};
use serde::Serialize;
use std::sync::Arc;

struct AppState {
    resend: Resend,
}

#[derive(Serialize)]
struct Empty {}

async fn example(
    State(state): State<Arc<AppState>>,
    Json(event): Json<resend_rs::events::EmailEvent>,
) -> Response {
    if matches!(
        event.r#type,
        resend_rs::events::EmailEventType::EmailReceived
    ) {
        let email = CreateEmailBaseOptions::new(
            "Acme <onboarding@resend.dev>",
            vec!["delivered@resend.dev"],
            format!("Re: {}", event.data.subject),
        )
        .with_html("<p>Thanks for your email!</p>")
        .with_header("In-Reply-To", &event.data.message_id);

        let data = state.resend.emails.send(email).await.unwrap();
        Json(data).into_response()
    } else {
        Json(Empty {}).into_response()
    }
}
```

## Replying multiple times in a thread

If you're replying multiple times within the same thread, make sure to also append
the previous `message_id`s to the `References` header, separated by spaces.
This helps email clients maintain the correct threading structure.

```ts Node.js {14-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend, type EmailReceivedEvent } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export async function replyInThread(event: EmailReceivedEvent) {
  const previousReferences = ['<msg_id1@domain.com>', '<msg_id2@domain.com>'];

  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: `Re: ${event.data.subject}`,
    html: '<p>Thanks for your email!</p>',
    headers: {
      'In-Reply-To': event.data.message_id,
      'References': [...previousReferences, event.data.message_id].join(' '),
    },
  });
}
```

```php PHP {13-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$event = json_decode(file_get_contents('php://input'), true);

$previousReferences = ['<msg_id1@domain.com>', '<msg_id2@domain.com>'];

$data = $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => "Re: {$event['data']['subject']}",
    'html' => '<p>Thanks for your email!</p>',
    'headers' => [
        'In-Reply-To' => $event['data']['message_id'],
        'References' => implode(' ', [...$previousReferences, $event['data']['message_id']]),
    ],
]);
```

```python Python {14-15} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

def handle_email_received(event: resend.EmailReceivedEvent):
    previous_references = ["<msg_id1@domain.com>", "<msg_id2@domain.com>"]

    params: resend.Emails.SendParams = {
        "from": "Acme <onboarding@resend.dev>",
        "to": ["delivered@resend.dev"],
        "subject": f"Re: {event['data']['subject']}",
        "html": "<p>Thanks for your email!</p>",
        "headers": {
            "In-Reply-To": event["data"]["message_id"],
            "References": " ".join([*previous_references, event["data"]["message_id"]]),
        },
    }

    email = resend.Emails.send(params)
```

```rb Ruby {13-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

previous_references = ["<msg_id1@domain.com>", "<msg_id2@domain.com>"]

params = {
    from: "Acme <onboarding@resend.dev>",
    to: ["delivered@resend.dev"],
    subject: "Re: #{event['data']['subject']}",
    html: "<p>Thanks for your email!</p>",
    headers: {
        "In-Reply-To": event["data"]["message_id"],
        "References": [*previous_references, event["data"]["message_id"]].join(" "),
    },
}

sent = Resend::Emails.send(params)
```

```go Go {32-33} theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/resend/resend-go/v4"
)

func main() {
    ctx := context.TODO()
    client := resend.NewClient("re_xxxxxxxxx")

    var event struct {
        Data struct {
            MessageId string `json:"message_id"`
            Subject   string `json:"subject"`
        } `json:"data"`
    }

    previousReferences := []string{"<msg_id1@domain.com>", "<msg_id2@domain.com>"}

    allReferences := append(previousReferences, event.Data.MessageId)

    params := &resend.SendEmailRequest{
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"delivered@resend.dev"},
        Subject: fmt.Sprintf("Re: %s", event.Data.Subject),
        Html:    "<p>Thanks for your email!</p>",
        Headers: map[string]string{
            "In-Reply-To": event.Data.MessageId,
            "References":  strings.Join(allReferences, " "),
        },
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
        panic(err)
    }
    fmt.Println(sent.Id)
}
```

```rust Rust {19-20} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::events::EmailEvent;
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

async fn reply(resend: &Resend, event: EmailEvent) -> Result<()> {
    let subject = format!("Re: {}", event.data.subject);
    let previous_references = vec!["<msg_id1@domain.com>", "<msg_id2@domain.com>"];

    let all_references = [previous_references, vec![event.data.message_id.as_str()]]
        .concat()
        .join(" ");

    let email = CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        ["delivered@resend.dev"],
        &subject,
    )
    .with_html("<p>Thanks for your email!</p>")
    .with_header("In-Reply-To", &event.data.message_id)
    .with_header("References", &all_references);

    let _email = resend.emails.send(email).await?;

    Ok(())
}
```

```java Java {25-26} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;
import com.resend.services.receiving.model.ReceivedEmail;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class Main {
    public static void reply(ReceivedEmail event) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        List<String> previousReferences = List.of("<msg_id1@domain.com>", "<msg_id2@domain.com>");

        List<String> allReferences = new ArrayList<>(previousReferences);
        allReferences.add(event.getMessageId());

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("Re: " + event.getSubject())
                .html("<p>Thanks for your email!</p>")
                .headers(Map.of(
                    "In-Reply-To", event.getMessageId(),
                    "References", String.join(" ", allReferences)
                ))
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET {18-19} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

async Task ReplyAsync(ReceivedEmail eventData)
{
    var previousReferences = new List<string> { "<msg_id1@domain.com>", "<msg_id2@domain.com>" };
    previousReferences.Add(eventData.MessageId);

    var message = new EmailMessage()
    {
        From = "Acme <onboarding@resend.dev>",
        To = "delivered@resend.dev",
        Subject = $"Re: {eventData.Subject}",
        HtmlBody = "<p>Thanks for your email!</p>",
        Headers = new Dictionary<string, string>()
        {
            { "In-Reply-To", eventData.MessageId },
            { "References", string.Join(" ", previousReferences) },
        },
    };

    var resp = await resend.EmailSendAsync(message);
}
```

```bash cURL {10-11} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "Re: Sending this example",
  "html": "<p>Thanks for your email!</p>",
  "headers": {
    "In-Reply-To": "<111-222-333@email.example.com>",
    "References": "<msg_id1@domain.com> <msg_id2@domain.com> <111-222-333@email.example.com>"
  }
}'
```

```bash CLI {6-7} theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@resend.dev>" \
  --to delivered@resend.dev \
  --subject "Re: Sending this example" \
  --html "<p>Thanks for your email!</p>" \
  --headers "In-Reply-To=<111-222-333@email.example.com>" \
    "References=<msg_id1@domain.com> <msg_id2@domain.com> <111-222-333@email.example.com>"
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{events::EmailEvent, types::CreateEmailBaseOptions, Resend};

async fn reply(resend: &Resend, event: EmailEvent) {
    let previous_references = [
        "<msg_id1@domain.com>",
        "<msg_id2@domain.com>",
        &event.data.message_id,
    ];

    let email = CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        vec!["delivered@resend.dev"],
        format!("Re: {}", event.data.subject),
    )
    .with_html("<p>Thanks for your email!</p>")
    .with_header("In-Reply-To", &event.data.message_id)
    .with_header("References", &previous_references.join(" "));

    let data = resend.emails.send(email).await.unwrap();
}
```


# Managing Billing
Source: https://resend.com/docs/dashboard/settings/billing

Manage your account subscription and billing information

The [Billing](https://resend.com/settings/billing) page in the Settings section provides a clear view of your subscription details, billing email, payment method, and account invoices. From here, you can:

* View and manage your subscription - Upgrade, downgrade, or modify your current plan.
* Update the billing email - Set the single address that receives invoices and billing-related notifications.
* Update payment information - Add or change your credit card or billing details.
* Add billing address - Provide your billing address for invoices.
* Add tax ID - Add your VAT number or tax ID for proper invoicing.
* Access invoices - Download past invoices for your records.

For any other billing inquiries, please [contact support](https://resend.com/help).

## Billing email recipients

Each team has one billing email address. Invoices and billing notifications are sent only to that address, and it cannot be set to multiple recipients.

If more than one person needs to receive invoices, you have two options:

* Set the billing email to a distribution list or alias that forwards to everyone who needs it.
* [Invite them to your team](/docs/dashboard/settings/team). Team members can open the [Billing](https://resend.com/settings/billing) page to view and download every invoice.

## How to cancel your subscription

1. Go to the [Billing](https://resend.com/settings/billing) page.
2. Click on the three dots  next to your plan.
3. Select **Cancel Subscription** from the dropdown menu.

![Cancel subscription](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-billing.jpg?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=3331d4b449ffd37fc0fe24f89e6f7dde)


# Single Sign-On
Source: https://resend.com/docs/dashboard/settings/sso

Let your team sign in to Resend with your identity provider

Single Sign-On (SSO) lets everyone with an email address on your organization's domain sign in to Resend through your own identity provider. With [**Enforce SSO**](#enforce-sso) turned on, your provider becomes the only way in, so removing someone there also removes their access to Resend.

## Requirements

* SSO is available as an add-on on Scale plans, and included on Enterprise plans. See [pricing](https://resend.com/pricing) for details.
* You must be an **Admin** of the team.
* Your own email address must be on the domain you want to use for SSO. For example, to set up SSO for `acme.com`, you must be signed in as `you@acme.com`.

## Set up SSO

**1. Start the setup from Team Settings**

Navigate to your [**Team Settings**](https://resend.com/settings/team) and click **Enable SSO**.

![Enable SSO button highlighted in team settings](https://mintcdn.com/resend/QCXwWXz0oyMSY7ls/images/sso-enable.png?fit=max\&auto=format\&n=QCXwWXz0oyMSY7ls\&q=85\&s=8a21c9080d4719fc1cf1ca04a56617f3)

> [!NOTE]
>
> If you are on a Scale plan and don't see the option to enable SSO, add the SSO
> add-on from your [**Usage**](https://resend.com/settings/usage) page first.

**2. Enter your organization domain**

This is the email domain your team members use to log in. It doesn't have to match the domains you use to send or receive email.

![Domain step with the organization domain field](https://mintcdn.com/resend/QCXwWXz0oyMSY7ls/images/sso-domain.png?fit=max\&auto=format\&n=QCXwWXz0oyMSY7ls\&q=85\&s=cc0e416311ad5047b3650cb4e3798c88)

**3. Add the TXT record to your DNS**

Resend issues a `TXT` record that proves you own the domain. Add it at the apex of your domain:

| Type | Name | Content | TTL |
| - | - | - | - |
| TXT | @ | `resend-domain-verification=<value>` | Auto |

Copy the value from the Dashboard rather than typing it, since it's unique to your domain.

![DNS record step showing the TXT record table](https://mintcdn.com/resend/QCXwWXz0oyMSY7ls/images/sso-records.png?fit=max\&auto=format\&n=QCXwWXz0oyMSY7ls\&q=85\&s=fb43fd3ccabf902b9a63b2e2fdf3de1e)

If the domain is already verified for sending in Resend, it's verified for SSO right away. This step and the next one are marked complete for you, so continue from **Configure SSO**.

> [!TIP]
>
> If you don't manage DNS yourself, use **Copy instructions** to email the record to your DNS administrator. For security, instructions can only be sent to your own address or to an address on the domain you're verifying.

**4. Wait for verification**

Click **I've added the record**. Resend checks your DNS repeatedly for up to an hour and updates the page as it goes. DNS changes usually propagate within a few minutes.

**5. Connect your identity provider**

Once the domain is verified, click **Finish setup**. A new tab opens where you configure the connection to your identity provider.

When you return to Resend, the Single Sign-On section of your [**Team Settings**](https://resend.com/settings/team) shows SSO as enabled.

If you leave the setup before finishing, your progress is kept. Return to [**Team Settings**](https://resend.com/settings/team) and click **Continue SSO setup** to pick up where you left off.

## Sign in with SSO

Team members sign in at [resend.com/login](https://resend.com/login):

1. They enter their email address.
2. If their domain has SSO configured, they're offered **Continue with SSO**.
3. They authenticate with your identity provider and land in the team.

Anyone who signs in through SSO and isn't yet a member of the team is added automatically with the **Member** role. No invitation is needed. To give someone Admin access, [change their role](/docs/dashboard/settings/team#change-the-team-member-roles) in Team Settings.

## Enforce SSO

By default, members can still sign in with a password, Google, or GitHub. Turn on **Enforce SSO** in the Single Sign-On section of your [**Team Settings**](https://resend.com/settings/team) to require SSO instead.

When enforcement is on, anyone whose email address is on your SSO domain is redirected to your identity provider, including attempts to sign in with a password, Google, or GitHub. Only Admins can change this setting.

> [!WARNING]
>
> Complete at least one successful SSO sign-in before turning on enforcement. If
> your identity provider becomes unreachable while enforcement is on, accounts
> on the SSO domain can't sign in. Keeping one Admin account on an email address
> outside the SSO domain gives you a way back in.

## Restrict joining other teams

Resend can also prevent accounts on your SSO domain from taking your organization's identity into unrelated teams. When this restriction is enabled, accounts on your SSO domain can't:

* create new teams
* be invited to, or accept invitations from, teams outside your SSO organization

This isn't a self-serve setting. [Contact support](https://resend.com/help) if you want it enabled for your domain.

## Disable SSO

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. In the Single Sign-On section, toggle **Disable SSO**.
3. Type `DISABLE SSO` to confirm.

This permanently removes your team's SSO configuration, including the verified SSO domain. Your sending and receiving domains aren't affected. Team members sign in with a password until you set SSO up again.

> [!NOTE]
>
> The SSO domain can't be edited after setup. To use a different domain, disable
> SSO and set it up again.

## Troubleshooting

**"We couldn't find the TXT record"**

The record isn't visible to Resend yet. Confirm it was added at the apex of the domain (`@`, not a subdomain), then click **I've added the record** to check again. Some DNS providers take longer than a few minutes to propagate.

**"We found a TXT record, but its value doesn't match"**

There's a `resend-domain-verification` record on the domain with a different value, usually left over from an earlier setup. Replace its content with the value shown in the Dashboard and verify again.

**Verification stopped without finishing**

Resend stops checking after an hour. Fix the record, then start a new check with **I've added the record**.

**Setup shows as unfinished**

The identity provider connection was never completed. Open [**Team Settings**](https://resend.com/settings/team), click **Continue SSO setup**, and finish the last step.

**A member isn't offered "Continue with SSO"**

Their email domain must match your verified SSO domain, and the setup must be complete. Confirm SSO shows as enabled in Team Settings.

**Non-admins can't change SSO settings**

Members can see the team's SSO configuration, but only Admins can set it up, enforce it, or disable it.

If you're still stuck, [contact support](https://resend.com/help).


# Managing Teams
Source: https://resend.com/docs/dashboard/settings/team

Manage your account across multiple teams

Resend allows multiple teams to be managed under a single email address. Each team is distinct, with its own API keys, billing, and usage.

## Inviting new members to a team

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Click **Invite**. Input an email address and select a role (**Admin** or **Member**).
   * **Members** have access to manage emails, domains and webhooks.
   * **Admins** have all Member permissions plus the ability to invite users, update payments, and delete the team.
3. The new member will receive an email invitation to join the team.

## Add a team avatar

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Click **Upload Image** next to the avatar placeholders.
3. Upload an image file to use as the team avatar.

<video />

## Switching between teams

After accepting an invite from the account owner, users can switch between teams:

1. Click on the **team name** in the top left corner of any Resend page.
2. A dropdown menu will appear, listing all the teams you belong to.
3. Select a team to switch between them.

![image](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/teams-toggle.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=d873d8c43f65af895d4fb025648f59d9)

## Change the team member roles

As an admin of your team, you can change the role of members in your team.

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Find the user you want to change.
3. Select the more options button  and choose **Change role**.

![Change role popover visible for team member](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/how-can-i-change-team-roles-1.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=656430ad540c2b6143998583b2a71c97)

Upon confirmation, your team member will be given the new role.

## Check team members' MFA status

The **Enabled MFA** column on your [**Team Settings**](https://resend.com/settings/team) page shows a checkmark next to each member who has multi-factor authentication (MFA) enabled. Every member of the team can see this column, not just admins. There is no setting to require MFA for the whole team. See [how to add MFA](/docs/knowledge-base/how-can-i-add-mfa) for how each member enables it on their own account.

## Leave your Resend team

You can leave your team by following these steps:

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Under members, click on  next to your name for more options.
3. Select the **Leave Team** button.

Upon confirmation, you will leave your team.

> [!NOTE]
>
> If you are the last member of the team, leaving will permanently delete the
> team and all its data. You will be prompted to confirm this action by typing
> **DELETE**. If the team still has other members, but you are the only admin,
> you will be prompted to promote another member to admin before leaving.


# Custom Unsubscribe Page
Source: https://resend.com/docs/dashboard/settings/unsubscribe-page

Customize your unsubscribe page

When using Resend Broadcasts or Automations, Resend can [automatically handle the unsubscribe flow for you](/docs/dashboard/contacts/managing-unsubscribe-list).

You can customize your unsubscribe page to match your brand. Your unsubscribe page is used for every domain on your team.

1. Navigate to your [**Unsubscribe Page**](https://resend.com/settings/unsubscribe-page).
2. Click **Edit**.

You can customize the following:

* **Title**: The title of the unsubscribe page.
* **Description**: The description of the unsubscribe page.
* **Logo**: The logo of the unsubscribe page.
* **Background Color**: The background color of the unsubscribe page.
* **Text Color**: The text color of the unsubscribe page.
* **Accent Color**: The accent color of the unsubscribe page.

<video />

> [!NOTE]
>
> Pro plan users or higher can also remove the “Powered by Resend” footer.


# Create a Template
Source: https://resend.com/docs/dashboard/templates/create-template

Learn how to create a Template in the Resend Dashboard editor or with the API.

## Creating Templates

You can draft and publish reusable email Templates with Resend's no-code editor or programmatically.

Templates allow you to send your frequently used transactional emails without needing to include the entire HTML body content. You can also include [Template variables](/docs/dashboard/templates/template-variables) that will be replaced with personalized information when sending, such as a customer's first name.

You can create a new transactional email Template in several ways:

* [Dashboard editor](#add-a-template-in-the-dashboard)
* [API](#add-a-template-with-the-api)
* [CLI](/docs/cli#templates)
* [HTML file](#add-a-template-from-an-existing-file)
* [React Email](/docs/knowledge-base/template-emails-with-react-email)
* [Duplicate a Template](#duplicate-a-template)
* [Clone a Broadcast](#clone-a-broadcast)

A new Template must be [published](#publish-a-template) before it can be used to send emails.

## Add a Template in the Dashboard

To create and publish a new Template using the no-code editor:

**1. Go to the Templates page in your Resend dashboard.**

**2. Click Create template.**

**3. Add sender info.**

Choose any username at your [verified domain](/docs/add-a-domain) to send your email from.

We suggest you choose a `from` name and address that assures the reader the email is coming from you, for example:

* `My Company Name <company@email.example.com>`

**4. Create a subject for your email.**

**5. Optionally define other email fields.**

Resend's no-code Template editor allows you to specify optional fields such as a different Reply-to address or preview text for email clients.

**6. Write your email content.**

You can use `/` commands in the Template editor for UI elements such as headings, lists, and images. You can also [compose your body text in Markdown](/docs/dashboard/templates/template-editor#markdown-support) and [add Template variables](/docs/dashboard/templates/template-variables) to personalize content.

Alternatively, you can paste or drag in content from [an existing HTML or React Email file](#add-a-template-from-an-existing-file).

**7. Use the sidebar to add custom styles.**

When you select an element such as text, images, or the entire page, you will see contextual styling menu options in the page sidebar. Choose colors, sizes, layouts, and more in the sidebar or add your own global CSS styles directly in the editor.

**8. Send yourself a test email.**

Click `Test email` and add one or more email addresses to send a test email. You will see any Template variables and can update their default values before sending.

<video />

**9. Publish your Template.**

Click `Publish` to prompt Resend's review feature. This will check for any errors or concerns with your Template and allow you to catch common mistakes before publishing.

**10. Slide to confirm.**

When there are no errors, the "Slide to publish" element will be active. Slide the arrow to confirm that you are ready to publish your Template. Only published Templates can be used to send emails.

Alternatively, exit the editor to leave your Template saved as a draft. It is automatically saved as you compose.

## Add a Template with the API

Programmatically create a Template from your application with the [Templates API](/docs/api-reference/templates/create-template). The payload can optionally include [variables to be used in the template](/docs/dashboard/templates/template-variables).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.templates.create({
  name: 'order-confirmation',
  from: 'Resend Store <store@example.com>',
  subject: 'Thanks for your order!',
  html: '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
  variables: [
    {
      key: 'PRODUCT',
      type: 'string',
      fallbackValue: 'item',
    },
    {
      key: 'PRICE',
      type: 'number',
      fallbackValue: 20,
    },
  ],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->templates->create([
  'name' => 'order-confirmation',
  'from' => 'Resend Store <store@example.com>',
  'subject' => 'Thanks for your order!',
  'html' => '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
  'variables' => [
    [
      'key' => 'PRODUCT',
      'type' => 'string',
      'fallback_value' => 'item'
    ],
    [
      'key' => 'PRICE',
      'type' => 'number',
      'fallback_value' => 49.99
    ]
  ]
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Templates.CreateParams = {
    "name": "order-confirmation",
    "from": "Resend Store <store@example.com>",
    "subject": "Thanks for your order!",
    "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    "variables": [
        {
            "key": "PRODUCT",
            "type": "string",
            "fallback_value": "item",
        },
        {
            "key": "PRICE",
            "type": "number",
            "fallback_value": 20,
        },
    ],
}

resend.Templates.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Templates.create(
  name: "order-confirmation",
  from: "Resend Store <store@example.com>",
  subject: "Thanks for your order!",
  html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  variables: [
    {
      key: "PRODUCT",
      type: "string",
      fallback_value: "item"
    },
    {
      key: "PRICE",
      type: "number",
      fallback_value: 20
    }
  ]
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
import "github.com/resend/resend-go/v4"

client := resend.NewClient("re_xxxxxxxxx")

client.Templates.Create(&resend.CreateTemplateRequest{
	Name:    "order-confirmation",
	From:    "Resend Store <store@example.com>",
	Subject: "Thanks for your order!",
	Html:    "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
	Variables: []*resend.TemplateVariable{
		{
			Key:           "PRODUCT",
			Type:          resend.VariableTypeString,
			FallbackValue: "item",
		},
		{
			Key:           "PRICE",
			Type:          resend.VariableTypeNumber,
			FallbackValue: 20,
		},
	},
})
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateTemplateOptions, Variable, VariableType},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let name = "order-confirmation";
  let from = "Resend Store <store@example.com>";
  let subject = "Thanks for your order!";
  let html = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>";

  let variables = [
    Variable::new("PRODUCT", VariableType::String).with_fallback("item"),
    Variable::new("PRICE", VariableType::Number).with_fallback(20)
  ];

  let opts = CreateTemplateOptions::new(name, html)
    .with_from(from)
    .with_subject(subject)
    .with_variables(&variables);

  let template = resend.templates.create(opts).await?;

  let _published = resend.templates.publish(&template.id).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.templates.model.CreateTemplateOptions;
import com.resend.services.templates.model.CreateTemplateResponseSuccess;
import com.resend.services.templates.model.Variable;
import com.resend.services.templates.model.VariableType;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateTemplateOptions params = CreateTemplateOptions.builder()
                .name("order-confirmation")
                .from("Resend Store <store@example.com>")
                .subject("Thanks for your order!")
                .html("<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>")
                .addVariable(new Variable("PRODUCT", VariableType.STRING, "item"))
                .addVariable(new Variable("PRICE", VariableType.NUMBER, 20))
                .build();

        CreateTemplateResponseSuccess data = resend.templates().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create("re_xxxxxxxxx");

var variables = new List<TemplateVariable>
{
  new TemplateVariable() {
    Key = "PRODUCT",
    Type = TemplateVariableType.String,
    Default = "item",
  },
  new TemplateVariable() {
    Key = "PRICE",
    Type = TemplateVariableType.Number,
    Default = 20,
  },
};

var resp = await resend.TemplateCreateAsync(
  new TemplateData()
  {
    Name = "order-confirmation",
    From = "Resend Store <store@example.com>",
    Subject = "Thanks for your order!",
    HtmlBody = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    Variables = variables,
  }
);

Console.WriteLine($"Template Id={resp.Content}");
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/templates' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "order-confirmation",
  "from": "Resend Store <store@example.com>",
  "subject": "Thanks for your order!",
  "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  "variables": [
    {
      "key": "PRODUCT",
      "type": "string",
      "fallback_value": "item"
    },
    {
      "key": "PRICE",
      "type": "number",
      "fallback_value": 20
    }
  ]
}'
```

## Add a Template from an existing file

You can create a Template from existing resources such as an HTML or [React Email](https://react.email) file.

[Create a new Template in the Dashboard](#add-a-template-in-the-dashboard), then paste or drag in your HTML or React Email content.

> [!NOTE]
>
> When pasting React Email code, only imports from `@react-email/components` and
> `react` are supported. Local file imports (e.g., `./components/Logo`) and
> other third-party packages are not supported in the editor.

## Duplicate a Template

You can duplicate an existing Template in the Dashboard, [via the Templates API](/docs/api-reference/templates/duplicate-template), or with a [Templates CLI command](/docs/cli#templates).

![Duplicate a template](https://mintcdn.com/resend/8sUIFX1U2gAd2pqE/images/templates-introduction-duplicate.png?fit=max\&auto=format\&n=8sUIFX1U2gAd2pqE\&q=85\&s=05d9c56edfa20ed9e03b3a83c01cd130)

## Clone a Broadcast

You can turn any sent [Broadcast](/docs/dashboard/broadcasts/introduction) into a reusable Template. Cloning reuses a Broadcast's design and content as a starting point for transactional emails.

Locate your desired Broadcast in the [Broadcast dashboard](https://resend.com/broadcasts), click the more options button , and choose **Clone as Template**.

## Publish a Template

By default, Templates are in a **draft** state. To use a Template to send emails, you must first **publish** it via the Dashboard, using the [Templates API](/docs/api-reference/templates/publish-template), or with a [Templates CLI command](/docs/cli#templates).

![Publish a template](https://mintcdn.com/resend/8sUIFX1U2gAd2pqE/images/templates-introduction-publish.png?fit=max\&auto=format\&n=8sUIFX1U2gAd2pqE\&q=85\&s=c39c711baf5719d8199ecdc3b2221480)

For a more streamlined flow in your application, you can create and publish a Template in a single step.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.templates
  .create({
    name: 'order-confirmation',
    html: '<p>Thanks for your order!</p>',
  })
  .publish();
```

## Edit a Template

You can only send emails using the most recently published version of a Template. Once a Template is published, you can continue to edit it as a draft without impacting any emails sent using the Template.

To use an updated version of your Template, you must publish your Template again to create a new version for sending. Until you republish, any edits are only saved in draft form. After you publish a new version, your changes will then be reflected in any future emails using the Template.

[Learn more about editing Templates in production safely with version history](/docs/dashboard/templates/version-history).

## Delete a Template

You can delete a Template via the Dashboard by clicking on the **Delete** button, [via the Templates API](/docs/api-reference/templates/delete-template), or with a [Templates CLI command](/docs/cli#templates).

![Delete a template](https://mintcdn.com/resend/8sUIFX1U2gAd2pqE/images/templates-introduction-delete.png?fit=max\&auto=format\&n=8sUIFX1U2gAd2pqE\&q=85\&s=5e7bc7c5e86e28f831c1d133d7961d73)

## API Reference

For complete API documentation, see the [Templates API reference](/docs/api-reference/templates/create-template) and the [`template` parameter of the Sending API](/docs/api-reference/emails/send-email#param-template).


# Using Templates
Source: https://resend.com/docs/dashboard/templates/introduction

Learn how to use Templates to send transactional emails.

## Email Templates

With Templates, you can define the structure and layout of a message once, then reuse it for multiple emails.

Use Templates for [transactional emails](/docs/email-types#send-transactional-emails) you send often, like:

* Login/Auth
* Onboarding
* Ecommerce
* Notifications
* Automations

## Template Features

With Resend's Template features, you can:

* Compose with Resend's [no-code Template editor](/docs/dashboard/templates/template-editor).
* Edit and update Templates with access to full [version history](/docs/dashboard/templates/version-history).
* Include [custom variables](/docs/dashboard/templates/template-variables) to personalize content.

You can even [embed the React Email editor](/docs/knowledge-base/embed-react-email-editor) in your own application to let your users create their own transactional emails from Templates and ship HTML-ready email content directly to Resend.

## Choose your infrastructure

To [create transactional email Templates](/docs/dashboard/templates/create-template), you can use a variety of tools:

* [Editor](/docs/dashboard/templates/template-editor): create using Resend's no-code editor
* [SDKs](/docs/sdks): create with an SDK built for your language
* [Integrations](/docs/integrations): create with a framework or tool you already use
* [API](/docs/api-reference/templates/create-template): create with raw cURL calls
* [CLI](/docs/cli#emails): create templates from the terminal
* [MCP](/docs/mcp-server): create through your agent with MCP
* [React Email](/docs/knowledge-base/template-emails-with-react-email): create from a React Email Template file
* [HTML](/docs/dashboard/templates/create-template#add-a-template-from-an-existing-file): create from an HTML file

## Send Emails with Templates

When you send a transactional email from your application, you can reference a [published Template](/docs/dashboard/templates/create-template#publish-a-template) to use as your content instead of passing the HTML directly.

Specify the Template ID and include any [Template variables](/docs/dashboard/templates/template-variables) in your API endpoint or CLI command. Resend will replace the Template variables with the actual variables specified in your code.

```ts Node.js {8-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: 'delivered@resend.dev',
  template: {
    id: 'order-confirmation',
    variables: {
      PRODUCT: 'Vintage Macintosh',
      PRICE: 499,
    },
  },
});
```

```php PHP {7-12} theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'template'=> [
    'id' => 'f3b9756c-f4f4-44da-bc00-9f7903c8a83f',
    'variables' => [
      'PRODUCT' => 'Vintage Macintosh',
      'PRICE' => 499,
    ]
  ]
]);
```

```python Python {8-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Emails.send({
  "from": "Acme <onboarding@resend.dev>",
  "to": "delivered@resend.dev",
  "template": {
    "id": "order-confirmation",
    "variables": {
      "PRODUCT": "Vintage Macintosh",
      "PRICE": 499
    }
  }
})
```

```ruby Ruby {8-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Emails.send({
  from: "Acme <onboarding@resend.dev>",
  to: "delivered@resend.dev",
  template: {
    id: "order-confirmation",
    variables: {
      PRODUCT: "Vintage Macintosh",
      PRICE: 499
    }
  }
})
```

```go Go {8-14} theme={"theme":{"light":"github-light","dark":"vesper"}}
import "github.com/resend/resend-go/v4"

client := resend.NewClient("re_xxxxxxxxx")

params := &resend.SendEmailRequest{
  From: "Acme <onboarding@resend.dev>",
  To: []string{"delivered@resend.dev"},
  Template: &resend.EmailTemplate{
    Id: "order-confirmation",
    Variables: map[string]interface{}{
      "PRODUCT": "Vintage Macintosh",
      "PRICE": 499,
    },
  },
}

client.Emails.Send(params)
```

```rust Rust {11-13,20} theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  json,
  types::{CreateEmailBaseOptions, EmailTemplate},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let template = EmailTemplate::new("order-confirmation")
    .with_variable("PRODUCT", json!("Vintage Macintosh"))
    .with_variable("PRICE", json!(499));

  let email = CreateEmailBaseOptions::new(
    "Acme <onboarding@resend.dev>",
    ["delivered@resend.dev"],
    "hello world",
  )
  .with_template(template);

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java {11-13,18-21} theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;
import com.resend.services.emails.model.Template;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

Resend resend = new Resend("re_xxxxxxxxx");

Map<String, Object> variables = new HashMap<>();
variables.put("PRODUCT", "Vintage Macintosh");
variables.put("PRICE", 499);

CreateEmailOptions params = CreateEmailOptions.builder()
  .from("Acme <onboarding@resend.dev>")
  .to(Arrays.asList("customer@email.com"))
  .template(Template.builder()
    .id("order-confirmation")
    .variables(variables)
    .build())
  .build();

CreateEmailResponse data = resend.emails().send(params);
```

```csharp .NET {5-9,17-20} theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create("re_xxxxxxxxx");

var variables = new Dictionary<string, object>
{
  { "PRODUCT", "Vintage Macintosh" },
  { "PRICE", 499 }
};

var resp = await resend.EmailSendAsync(
  new EmailMessage()
  {
    From = "Acme <onboarding@resend.dev>",
    To = new[] { "delivered@resend.dev" },
    Template = new EmailMessageTemplate()
    {
      TemplateId = "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
      Variables = variables
    }
  }
);

Console.WriteLine($"Email Id={resp.Content}");
```

```bash cURL {7-13} theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
  -H 'Authorization: Bearer re_xxxxxxxxx' \
  -H 'Content-Type: application/json' \
  -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": "delivered@resend.dev",
    "template": {
      "id": "order-confirmation",
      "variables": {
        "PRODUCT": "Vintage Macintosh",
        "PRICE": 499
      }
    }
}'
```

## Related Guides

See how to use Resend's email Template features.

> [card] [Create Templates](/docs/dashboard/templates/create-template)

> [card] [Editor](/docs/dashboard/templates/template-editor)

> [card] [Template variables](/docs/dashboard/templates/template-variables)

> [card] [Version history](/docs/dashboard/templates/version-history)

> [card] [React Email Templates](/docs/knowledge-base/template-emails-with-react-email)

> [card] [Embed Email Editor](/docs/knowledge-base/embed-react-email-editor)


# Compose with the Template editor
Source: https://resend.com/docs/dashboard/templates/template-editor

Learn how to write reusable transactional email Templates in the Dashboard editor

## Template editor

Resend's no-code Template editor is built into the Dashboard to allow anyone on your team to create and update reusable transactional emails.

You can drag and drop an existing file, use slash commands to add content without leaving the keyboard, or compose in Markdown.

The included AI assistant can compose common transactional emails for you, such as welcome messages and password resets.

## Markdown Support

The editor supports writing your emails using Markdown headings, lists, italic, bold, links, and quotes.

If you copy and paste content from other rich or plain text applications, the editor maintains formatting consistency.

<video />

## Custom Styling

You can customize the look and feel of your email by changing **global styles** such as the background color, link color, and container size, allowing you to create emails aligned with your brand identity.

To do this, click on **Styles** at the top left of the Template editor. You can edit specific images or lines of texts by selecting or highlighting them prior to clicking on **Styles**.

<video />

You can also edit individual styles for each component, including the font size, font weight, letter spacing, line height, and text alignment. You can also set custom properties for each component, such as image alt, button links, and social links,

<video />

## Personalize your content

When creating Templates, you can include dynamic audience data to personalize the email content. Learn more about working with [template variables](/docs/dashboard/templates/template-variables).


# Working with Variables
Source: https://resend.com/docs/dashboard/templates/template-variables

How to work with custom variables in Templates.

## Template Variables

Custom Template variables provide your team flexibility when sending emails. Define custom variables for your Template with optional fallback values which will be replaced with the actual values when sending the email.

Each Template may contain up to 50 variables. You can define and then reference these variables in your Template to send emails with personalized content.

## Create custom variables

To add a custom variable to your Template, select **Variable** in the commands palette or type `{{` in the Dashboard editor. Define the `name`, `type`, and `fallback_value` (optional).

![variable dropdown](https://mintcdn.com/resend/j2QOddewHJcRH5o-/images/templates-introduction-variables-custom.png?fit=max\&auto=format\&n=j2QOddewHJcRH5o-\&q=85\&s=88a202c3830e629559bc01785a33a138)

You can also define custom variables when you [create a Template via the
API](/docs/dashboard/templates/create-template#add-a-template-with-the-api). The
payload can optionally include variables to be used in the Template.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.templates.create({
  name: 'order-confirmation',
  html: '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
  variables: [
    {
      key: 'PRODUCT',
      type: 'string',
      fallbackValue: 'item',
    },
    {
      key: 'PRICE',
      type: 'number',
      fallbackValue: 25,
    },
  ],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->templates->create([
  'name' => 'order-confirmation',
  'html' => '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
  'variables' => [
    [
      'key' => 'PRODUCT',
      'type' => 'string',
      'fallback_value' => 'item',
    ],
    [
      'key' => 'PRICE',
      'type' => 'number',
      'fallback_value' => 25,
    ]
  ],
]);
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Templates.create({
    "name": "order-confirmation",
    "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    "variables": [
        {
            "key": "PRODUCT",
            "type": "string",
            "fallback_value": "item",
        },
        {
            "key": "PRICE",
            "type": "number",
            "fallback_value": 25,
        }
    ],
})
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Templates.create(
  name: "order-confirmation",
  html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  variables: [
    {
      key: "PRODUCT",
      type: "string",
      fallback_value: "item"
    },
    {
      key: "PRICE",
      type: "number",
      fallback_value: 25
    }
  ]
)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Templates.CreateWithContext(context.TODO(), &resend.CreateTemplateRequest{
		Name: "order-confirmation",
		Html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
		Variables: []*resend.TemplateVariable{
			{
				Key:           "PRODUCT",
				Type:          resend.VariableTypeString,
				FallbackValue: "item",
			},
			{
				Key:           "PRICE",
				Type:          resend.VariableTypeNumber,
				FallbackValue: 25,
			},
		},
	})
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateTemplateOptions, Variable, VariableType},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let name = "order-confirmation";
  let html = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>";

  let variables = [
    Variable::new("PRODUCT", VariableType::String).with_fallback("item"),
    Variable::new("PRICE", VariableType::Number).with_fallback(25)
  ];

  let opts = CreateTemplateOptions::new(name, html).with_variables(&variables);
  let template = resend.templates.create(opts).await?;

  let _published = resend.templates.publish(&template.id).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.templates.model.CreateTemplateOptions;
import com.resend.services.templates.model.CreateTemplateResponseSuccess;
import com.resend.services.templates.model.Variable;
import com.resend.services.templates.model.VariableType;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateTemplateOptions params = CreateTemplateOptions.builder()
                .name("order-confirmation")
                .html("<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>")
                .addVariable(new Variable("PRODUCT", VariableType.STRING, "item"))
                .addVariable(new Variable("PRICE", VariableType.NUMBER, 25))
                .build();

        CreateTemplateResponseSuccess data = resend.templates().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create("re_xxxxxxxxx");

var variables = new List<TemplateVariable>()
{
  new TemplateVariable() {
    Key = "PRODUCT",
    Type = TemplateVariableType.String,
    Default = "item",
  },
  new TemplateVariable() {
    Key = "PRICE",
    Type = TemplateVariableType.Number,
    Default = 25,
  }
};

var resp = await resend.TemplateCreateAsync(
  new TemplateData()
  {
    Name = "welcome-email",
    HtmlBody = "<strong>Hey, {{{PRODUCT}}}, you are {{{PRICE}}} years old.</strong>",
    Variables = variables,
  }
);

Console.WriteLine($"Template Id={resp.Content}");
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/templates' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "order-confirmation",
  "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  "variables": [
    {
      "key": "PRODUCT",
      "type": "string",
      "fallback_value": "item"
    },
    {
      "key": "PRICE",
      "type": "number",
      "fallback_value": 25
    }
  ]
}'
```

> [!NOTE]
>
> The following variable names are reserved and cannot be used: `FIRST_NAME`,
> `LAST_NAME`, `EMAIL`, `UNSUBSCRIBE_URL`, `contact`,`this`.

Each variable is an object with the following properties:

* `key`: The key of the variable, commonly uppercase (e.g., `PRODUCT_NAME`).
* `type`: The type of the variable (`'string'` or `'number'`).
* `fallback_value`: The fallback value of the variable. If no fallback value is provided, you must provide a value for the variable when sending an email using the Template.

[See the API reference for more details](/docs/api-reference/templates/create-template).

## Fallback values

When you define a variable, you can optionally define a fallback value. This value will be used when sending the email if you fail to provide a value in your call.

<video />

In the editor, if you fail to provide a fallback value, a warning sign will show for the variable. To edit a variable's fallback value, click on the variable chip in your Template and use the Inspector sidebar on the right to update the fallback value.

You can also include fallback values when [creating a Template via the API](#create-template-with-variables).

## Send Test Emails

You can send test emails to your inbox to preview your Template before sending it to your audience. Provide variable values to test the rendered Template in your inbox.

<video />

## Send a Template with Variables

When sending a transactional email, you can reference your Template and include your variables in the call. The Template variables will be replaced with the actual values.

* `id`: id of the published Template
* `variables`: array of variable objects (if applicable)

Both the `/emails` and `/emails/batch` endpoints support Templates.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'hello world',
  template: {
    id: 'f3b9756c-f4f4-44da-bc00-9f7903c8a83f',
    variables: {
      PRODUCT: 'Laptop',
    },
  },
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'template'=> [
    'id' => 'f3b9756c-f4f4-44da-bc00-9f7903c8a83f',
    'variables' => [
      'PRODUCT' => 'Laptop'
    ]
  ]
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "template": {
        "id": "f3b9756c-f4f4-44da-bc00-9f7903c8a83f",
        "variables": {
            "PRODUCT": "Laptop",
        },
    },
}

email = resend.Emails.send(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require 'resend'

Resend.api_key = 're_xxxxxxxxx'

params = {
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'hello world',
  template: {
    id: 'f3b9756c-f4f4-44da-bc00-9f7903c8a83f',
    variables: {
      'PRODUCT': 'Laptop'
    }
  }
}

email = Resend::Emails.send(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.SendEmailRequest{
		From:    "Acme <onboarding@resend.dev>",
		To:      []string{"delivered@resend.dev"},
		Subject: "hello world",
		Template: &resend.EmailTemplate{
			Id: "f3b9756c-f4f4-44da-bc00-9f7903c8a83f",
			Variables: map[string]interface{}{
				"PRODUCT": "Laptop",
			},
		},
	}

	client.Emails.SendWithContext(context.TODO(), params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
	json,
	types::{CreateEmailBaseOptions, EmailTemplate},
	Resend, Result,
};
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<()> {
	let resend = Resend::new("re_xxxxxxxxx");

	let from = "Acme <onboarding@resend.dev>";
	let to = ["delivered@resend.dev"];
	let subject = "hello world";

	let mut variables = HashMap::new();
	variables.insert("PRODUCT".to_string(), json!("Laptop"));

	let template = EmailTemplate::new("f3b9756c-f4f4-44da-bc00-9f7903c8a83f").with_variables(variables);

	let email = CreateEmailBaseOptions::new(from, to, subject).with_template(template);

	let _email = resend.emails.send(email).await?;

	Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CreateEmailOptions;
import com.resend.services.emails.model.CreateEmailResponse;
import com.resend.services.emails.model.Template;
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        Map<String, Object> variables = new HashMap<>();
        variables.put("PRODUCT", "Laptop");

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("hello world")
                .template(Template.builder()
                        .id("f3b9756c-f4f4-44da-bc00-9f7903c8a83f")
                        .variables(variables)
                        .build())
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailSendAsync( new EmailMessage()
{
    From = "Acme <onboarding@resend.dev>",
    To = "delivered@resend.dev",
    Subject = "hello world",
    Template = new EmailMessageTemplate() {
      TemplateId = "f3b9756c-f4f4-44da-bc00-9f7903c8a83f",
      Variables = new Dictionary<string, object>()
      {
        { "PRODUCT", "Laptop" },
        { "PRICE", 1.23 }
      }
    }
} );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "template": {
    "id": "f3b9756c-f4f4-44da-bc00-9f7903c8a83f",
    "variables": {
      "PRODUCT": "Laptop"
    }
  }
}'
```

> [!NOTE]
>
> If a `template` is provided, you cannot send `html`, `text`, or `react` in the payload, otherwise the API will return a validation error.
>
> When sending a Template, the payload for `from`, `subject`, and `reply_to` take precedence over the Template's defaults for these fields. If the Template does not provide a default value for these fields, you must provide them in the payload.

Learn more about [sending emails](/docs/api-reference/emails/send-email) or sending [batch emails](/docs/api-reference/emails/send-batch-emails) with Templates via the API.

## Validation errors

When sending an email using a Template, the Template variables will be replaced with the actual values. If a variable is not provided, the fallback value will be used.

If no fallback value is provided, the email will not be sent and a [validation error](/docs/api-reference/errors) will be returned.

## API Reference

For complete API documentation, see the [Templates API reference](/docs/api-reference/templates/create-template) and the [`template` parameter of the Sending API](/docs/api-reference/emails/send-email#param-template).


# Version History
Source: https://resend.com/docs/dashboard/templates/version-history

Edit Templates safely in production environments with version history.

Templates in production require a workflow that lets you make changes safely without disrupting active emails. As you build your Template, your entire team can collaborate on the content and design in real-time with full version history.

## Draft vs Published

Templates start in a draft state and must be published before they can be used to send emails.

This separation allows you to:

* Test Templates thoroughly before going live
* Make changes without affecting active emails
* Maintain version control over your email content

Once you [publish a Template](/docs/dashboard/templates/create-template#publish-a-template), this published version will be used to send emails until you publish again. You can continue to work on a production Template in draft state without affecting the published version, and the editor will automatically save your progress.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
// Create template
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.templates.create({
  name: 'order-confirmation',
  from: 'Resend Store <store@resend.com>',
  subject: 'Thanks for your order!',
  html: '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
  variables: [
    {
      key: 'PRODUCT',
      type: 'string',
      fallbackValue: 'item',
    },
    {
      key: 'PRICE',
      type: 'number',
      fallbackValue: 20,
    },
  ],
});

// Publish template
await resend.templates.publish('template_id');

// Or create and publish a template in one step
const { data, error } = await resend.templates
  .create({
    name: 'order-confirmation',
    html: '<p>Thanks for your order!</p>',
  })
  .publish();
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

// Create template
$resend->templates->create([
  'name' => 'order-confirmation',
  'from' => 'Resend Store <store@resend.com>',
  'subject' => 'Thanks for your order!',
    'html' => "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  'variables' => [
    [
      'key' => 'PRODUCT',
      'type' => 'string',
      'fallback_value' => 'item'
    ],
    [
      'key' => 'PRICE',
      'type' => 'number',
      'fallback_value' => 49.99
    ]
  ]
]);

// Publish template
$resend->templates->publish('template_id');
```

```py Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

# Create template
params: resend.Templates.CreateParams = {
  "name": "order-confirmation",
  "from": "Resend Store <store@resend.com>",
  "subject": "Thanks for your order!",
  "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  "variables": [
    {
      "key": "PRODUCT",
      "type": "string",
      "fallback_value": "item"
    },
    {
      "key": "PRICE",
      "type": "number",
      "fallback_value": 20
    },
  ]
}

resend.Templates.create(params)

# Publish template
resend.Templates.publish('template_id');
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

# Create template
params = {
  "name": 'order-confirmation',
  "from": 'Resend Store <store@resend.com>',
  "subject": 'Thanks for your order!',
  "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  "variables": [{
      "key": 'PRODUCT',
      "type": 'string',
      "fallback_value": 'item'
    },
    {
      "key": 'PRICE',
      "type": 'number',
      "fallback_value": 20
    }
  ]
}

Resend::Templates.create(params)

# Publish template
Resend::Templates.publish('template_id');
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
import "github.com/resend/resend-go/v4"

client := resend.NewClient("re_xxxxxxxxx")

// Create template
params := &resend.CreateTemplateRequest{
  Name: "order-confirmation",
  From: "Resend Store <store@resend.com>",
  Subject: "Thanks for your order!",
  Html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  Variables: []*resend.TemplateVariable{
    {
      Key: "PRODUCT",
      Type: "string",
      FallbackValue: "item",
    },
    {
      Key: "PRICE",
      Type: "number",
      FallbackValue: 20,
    },
  },
}

template, _ := client.Templates.Create(params)

// Publish template
client.Templates.Publish(template.Id)
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{
  types::{CreateTemplateOptions, Variable, VariableType},
  Resend, Result,
};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  // Create template
  let name = "order-confirmation";
  let from = "Resend Store <store@resend.com>";
  let subject = "Thanks for your order!";
  let html = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>";

  let variables = [
    Variable::new("PRODUCT", VariableType::String).with_fallback("item"),
    Variable::new("PRICE", VariableType::Number).with_fallback(20),
  ];

  let opts = CreateTemplateOptions::new(name, html)
    .with_from(from)
    .with_subject(subject)
    .with_variables(&variables);

  let template = resend.templates.create(opts).await?;

  // Publish template
  resend.templates.publish(&template.id).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.services.templates.model.CreateTemplateOptions;
import com.resend.services.templates.model.CreateTemplateResponseSuccess;
import com.resend.services.templates.model.Variable;
import com.resend.services.templates.model.VariableType;
import java.util.Arrays;
import java.util.List;

Resend resend = new Resend("re_xxxxxxxxx");

// Create template
List<Variable> variables = Arrays.asList(
  new Variable("PRODUCT", VariableType.STRING, "item"),
  new Variable("PRICE", VariableType.NUMBER, 20)
);

CreateTemplateOptions params = CreateTemplateOptions.builder()
  .name("order-confirmation")
  .from("Resend Store <store@resend.com>")
  .subject("Thanks for your order!")
  .html("<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>")
  .variables(variables)
  .build();

CreateTemplateResponseSuccess data = resend.templates().create(params);

// Publish template
resend.templates().publish(data.getId());
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create("re_xxxxxxxxx");

// Create template
var variables = new List<TemplateVariable>
{
  new TemplateVariable() {
    Key = "PRODUCT",
    Type = TemplateVariableType.String,
    Default = "item",
  },
  new TemplateVariable() {
    Key = "PRICE",
    Type = TemplateVariableType.Number,
    Default = 20,
  },
};

var resp = await resend.TemplateCreateAsync(
  new TemplateData()
  {
    Name = "order-confirmation",
    From = "Resend Store <store@resend.com>",
    Subject = "Thanks for your order!",
    HtmlBody = @"
      <p>Name: {{{PRODUCT}}}</p>
      <p>Total: {{{PRICE}}}</p>
    ",
    Variables = variables,
  }
);

// Publish template
await resend.TemplatePublishAsync(resp.Content);

Console.WriteLine($"Template Id={resp.Content}");
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
# Create template
curl -X POST 'https://api.resend.com/templates' \
 -H 'Authorization: Bearer re_xxxxxxxxx' \
 -H 'Content-Type: application/json' \
 -d $'{
  "name": "order-confirmation",
  "from": "Resend Store <store@resend.com>",
  "subject": "Thanks for your order!",
  "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  "variables": [
    {
      "key": "PRODUCT",
      "type": "string",
      "fallbackValue": "item"
    },
    {
      "key": "PRICE",
      "type": "number",
      "fallbackValue": 20
    }
  ]
}'

# Publish template
curl -X POST 'https://api.resend.com/templates/{template_id}/publish' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json'
```

After you publish a Template, you can freely work on it through the editor or update it [via the Templates API](/docs/api-reference/templates/update-template) without affecting the published version. This allows you to test and validate new edits before sending them to users.

## Version History

Each Template contains a version history that helps you track changes your team has made over time. You can view the version history by clicking the three dots in the top right corner of the Template editor and selecting **Version History**.

As you work on a Template in the editor, your changes are saved as a draft, although you can also manually save drafts by pressing <kbd>Cmd</kbd> + <kbd>S</kbd> (Mac) or <kbd>Ctrl</kbd> + <kbd>S</kbd> (Windows). Only after publishing again will the changes be reflected in emails using the Template.

Through the version history, you can preview each version, who made them, and when they were made. You can also revert to a previous version if needed.

<video />

Reverting creates a new draft based on the selected version's content, without affecting the published Template.

## Edit a Template

You can work on a new draft version of your published Template, update the design and messaging, then test it thoroughly before publishing it again.

Your email sending will continue to use the current published version until you're ready to make the switch, without the need to create a new separate Template or risk leaking information like your new logo.

This behavior is also useful to avoid breaking changes when you need to edit a Template that's in production. Add or remove variables, update the design, and more without affecting your existing emails or raising validation errors.

## API reference

For complete API documentation, see the [updating Templates API reference](/docs/api-reference/templates/update-template).


# DMARC Analyzer
Source: https://resend.com/docs/dmarc-analyzer

Analyze DMARC XML reports with a free, open-source tool built by Resend.

[DMARC Analyzer](https://github.com/resend/resend-dmarc-analyzer) is an open-source tool built by Resend that parses DMARC XML reports and turns them into human-readable dashboards. You can use it directly in your browser or deploy your own instance to receive automated email digests.

## What is DMARC?

DMARC (Domain-based Message Authentication, Reporting, and Conformance) is an email authentication protocol that builds on [SPF and DKIM](/docs/dashboard/domains/introduction). It lets domain owners specify how unauthenticated emails are handled and receive reports about authentication results.

When you [set up a DMARC policy](/docs/dashboard/domains/dmarc), mailbox providers send XML reports to the address you specify. These reports contain valuable data about who is sending email on behalf of your domain and whether those emails pass authentication, but the raw XML is difficult to read. The DMARC Analyzer helps you visualize these reports in a human-readable format.

## Features

* Parse and visualize DMARC XML reports instantly
* View SPF and DKIM alignment results per source
* Identify unauthorized senders using your domain
* Self-host with automated report ingestion via [Resend Receiving](/docs/dashboard/receiving/introduction)
* Receive email digests summarizing your DMARC reports

> [!NOTE]
>
> For more details on understanding DMARC reports, see our [guide on how to read
> a DMARC report](https://resend.com/blog/how-to-read-a-dmarc-report).

## How to use

### Web interface

The quickest way to get started, with no setup required.

1. Go to [checkdmarc.email](https://checkdmarc.email/)
2. Paste your DMARC XML report (or upload the XML file)
3. View the parsed results instantly

<video />

### Self-hosted with automated reports

For ongoing monitoring, deploy your own instance. This connects to Resend Receiving webhooks so DMARC reports sent to your domain are automatically ingested and analyzed, with email digests delivered via Resend.

## Getting started (self-hosted)

**1. Clone the repository**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
git clone https://github.com/resend/resend-dmarc-analyzer.git
cd resend-dmarc-analyzer
```

**2. Install dependencies**

> [tab] pnpm
>
> `bash pnpm install `

> [tab] npm
>
> `bash npm install `

> [tab] yarn
>
> `bash yarn install `

> [tab] bun
>
> `bash bun install `

**3. Configure environment variables**

Copy the example environment file and fill in the required values:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
cp .env.example .env.local
```

| Variable | Description |
| - | - |
| `RESEND_API_KEY` | Your [Resend API key](https://resend.com/api-keys) |
| `RESEND_WEBHOOK_SECRET` | Signing secret from your [Resend webhook](https://resend.com/webhooks) endpoint set up below |
| `EMAIL_FROM` | Sender address for digest emails (must be from a [verified domain](https://resend.com/domains)) |
| `EMAIL_TO` | Recipient address for digest emails |

**4. Test the application**

Start the development server:

> [tab] pnpm
>
> `bash pnpm run dev `

> [tab] npm
>
> `bash npm run dev `

> [tab] yarn
>
> `bash yarn run dev `

> [tab] bun
>
> `bash bun run dev `

Register your publicly accessible HTTPS URL in the Resend dashboard and enable the `email.received` event.

* For `rua` reports: `https://example123.ngrok.io/api/webhooks/dmarc/rua`
* For `ruf` report: `https://example123.ngrok.io/api/webhooks/dmarc/ruf`

Copy the signing secret from the webhook details page to the `RESEND_WEBHOOK_SECRET` environment variable.

> [!TIP]
>
> For development, you can create a tunnel to your localhost server using a tool like
> [ngrok](https://ngrok.com/download) or [VS Code Port Forwarding](https://code.visualstudio.com/docs/debugtest/port-forwarding). These tools serve your local dev environment at a public URL you can use to test your local webhook endpoint.
>
> Example: `https://example123.ngrok.io/api/webhook`

**5. Deploy**

Deploy the application to your preferred hosting platform and update the webhook endpoint(s) in the Resend dashboard.

* For `rua` reports: `https://example.com/api/webhooks/dmarc/rua`
* For `ruf` reports: `https://example.com/api/webhooks/dmarc/ruf`

The project is built with [Next.js](https://nextjs.org) so it works with any platform that supports it (e.g., [Vercel](https://vercel.com)).

## Tech stack

DMARC Analyzer is built with [Next.js](https://nextjs.org), [React Email](https://react.email), and [Resend](https://resend.com). The full source code is available on [GitHub](https://github.com/resend/resend-dmarc-analyzer).


# Email Best Practices Skill
Source: https://resend.com/docs/email-best-practices-skill

Comprehensive guide for building production-ready email systems with AI agents.

The Email Best Practices skill provides AI agents with comprehensive knowledge for building production-ready email integrations in your applications. It covers authentication, compliance, deliverability, and operational best practices.

## Installation

Install the skill using the following command:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/email-best-practices
```

## Advantages

* **DNS authentication guidance**: Step-by-step instructions for setting up SPF, DKIM, and DMARC records.
* **Transactional and marketing email design**: Best practices for designing effective transactional and marketing emails.
* **Regional compliance**: Guidelines for CAN-SPAM, GDPR, CASL, and other regional email regulations.
* **Webhook event processing**: Patterns for handling delivery notifications, bounces, and complaints.
* **Suppression list management**: Strategies for maintaining healthy suppression lists and improving deliverability.

## Learn More

> [card] [View on GitHub](https://github.com/resend/email-best-practices)
>
> See the full source code and documentation.


# Sending emails with Resend
Source: https://resend.com/docs/email-types

Resend has a wide range of features for sending both transactional and marketing emails.

Resend provides an API, command-line interface (CLI), webhooks, and automations to support both types of emails you need to send:

* **Transactional emails:** personalized, event-driven communication
* **Marketing campaigns:** bulk email [Broadcasts](/docs/dashboard/broadcasts/introduction) distributed to a contact list

All of these email features and activities are also available through a user-friendly Dashboard and through AI tooling for agents. This allows your entire team to create and send emails, update automations, manage contacts, track performance, and more.

Get started with Resend's free plan, then choose from multiple [pricing plans and tiers](https://resend.com/pricing) depending on the number and type of emails you need to send as you grow.

## Send transactional emails

A **Transactional email** is a message triggered by a user action or required for legal compliance. Common examples include:

* Order confirmations
* Password reset emails
* Account notifications

Typically, transactional emails are **1-to-1** messages sent in response to a specific event.

With a Resend Transactional Plan, you can send transactional emails from your application using the [Resend API](/docs/api-reference/introduction), the [Resend CLI](/docs/cli), or with [SMTP](/docs/send-with-smtp). Resend also provides an [MCP server](/docs/mcp-server), [agent skills](/docs/react-email-skill), and more to work with your preferred [AI builder and tooling](/docs/ai-onboarding).

You can also trigger emails using [webhooks](/docs/webhooks/introduction), and even [create steps to automate emails](/docs/dashboard/automations/introduction) based on custom events from your application.

## Send bulk marketing emails

Marketing emails are **promotional**, **informative**, or **general communication** messages.

Marketing emails are regulated by laws like **CAN-SPAM** (US) and **CASL** (Canada), and **recipients must have the option to unsubscribe**.

Examples of marketing emails:

* Promotional offers and discounts
* Newsletters
* Product updates

Marketing emails are typically **1-to-many** messages, sent when you want to reach a larger audience (e.g., newsletters).

With a Resend Marketing Plan, you can send [Broadcasts](/docs/dashboard/broadcasts/introduction) to your subscribers using a no-code editor in your Resend Dashboard, or from the [Broadcast API](https://resend.com/docs/api-reference/broadcasts/create-broadcast).

When you use Broadcasts, you get tools for [managing your contacts](/docs/dashboard/contacts/introduction), [tracking performance](/docs/dashboard/broadcasts/performance-tracking), and [customizing your personal unsubscribe page](/docs/dashboard/settings/unsubscribe-page). Resend also handles all the queuing, throttling, and scheduling for you so that you don't have to roll your own infrastructure.

Marketing plans also allow you to create [Resend automations](/docs/dashboard/automations/introduction) for repeatable actions like welcoming new subscribers and updating your contact list. Resources such as the [Resend MCP server](/docs/mcp-server), [agent skills](/docs/react-email-skill), and more are all available to your preferred [AI builders and tooling](/docs/ai-onboarding) to help you send and manage your marketing emails.

## Send a combination of emails

It is common to need to send both transactional and marketing emails to your users. Your customers need personalized emails about their orders, but may also wish to subscribe to a newsletter that is delivered to your entire contact list.

Some emails do not fit neatly into one category:

* Marketing emails can be **1-to-1**, based on personalized user activity (e.g., abandoned cart reminders, drip marketing campaigns). You can use Resend's transactional APIs and automations to send these individual marketing emails, as long as proper consent and compliance regulations are followed.
* Resend's [batch sending API feature](/docs/dashboard/emails/batch-sending) can send multiple transactional emails at once (up to 100), even to different recipients with unique content, instead of making individual API requests for each email.

You can either go with Resend's opinionated, full-featured solutions or design your own architecture from the ground up. You can use all of Resend's features for any type of email sending that you can build. This includes APIs, CLI commands, webhooks, and automations, plus AI tools and Dashboard controls.

Resend allows you to choose both a Transactional and a Marketing plan, each at the tier that suits your specific use case for your email volume, and features needed. Update each plan individually at any time if your sending habits change, or add pay-as-you-go add-ons if you need a more flexible solution.

## Learn more

> [card] [Send Email API](/docs/api-reference/emails/send-email)
>
> Send, list, retrieve, update, and cancel transactional emails with the Send
> Email API.

> [card] [Broadcasts](/docs/dashboard/broadcasts/introduction)
>
> Create and send marketing emails with Resend's no-code editor or the
> Broadcasts API.

## Next steps

> [card] [Import or add email contacts](/docs/dashboard/contacts/add-contacts)
>
> Add existing subscribers to your Resend contact list programmatically,
> manually, or by uploading a `.csv` file.

> [card] [Quickstart tutorials](/docs/introduction)
>
> Send your first transactional email with a quick tutorial for your language
> or framework.


# Examples
Source: https://resend.com/docs/examples

Explore sample apps for different use cases.

## Frameworks

> [card] [Next.js (TypeScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript)
>
> Full-stack Next.js app with TypeScript

> [card] [Next.js (JavaScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript)
>
> Full-stack Next.js app with JavaScript

> [card] [Express](https://github.com/resend/resend-examples/tree/main/express-resend-examples)
>
> Express 5 examples (TypeScript and JavaScript)

> [card] [Hono](https://github.com/resend/resend-examples/tree/main/hono-resend-examples)
>
> Hono examples (TypeScript and JavaScript)

> [card] [Bun](https://github.com/resend/resend-examples/tree/main/bun-resend-examples)
>
> Bun examples (TypeScript and JavaScript)

> [card] [Remix](https://github.com/resend/resend-examples/tree/main/remix-resend-examples)
>
> Remix examples (TypeScript and JavaScript)

> [card] [Nuxt](https://github.com/resend/resend-examples/tree/main/nuxt-resend-examples)
>
> Nuxt 3 examples (TypeScript and JavaScript)

> [card] [SvelteKit](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples)
>
> SvelteKit examples (TypeScript and JavaScript)

> [card] [Astro](https://github.com/resend/resend-examples/tree/main/astro-resend-examples)
>
> Astro examples (TypeScript and JavaScript)

> [card] [RedwoodJS](https://github.com/resend/resend-examples/tree/main/redwoodjs-resend-examples)
>
> RedwoodJS examples (TypeScript and JavaScript)

> [card] [TanStack Start](https://github.com/resend/resend-examples/tree/main/tanstack-resend-examples)
>
> TanStack Start examples (TypeScript and JavaScript)

> [card] [PHP](https://github.com/resend/resend-examples/tree/main/php-resend-examples)
>
> PHP examples with Slim and Symfony

> [card] [Laravel](https://github.com/resend/resend-examples/tree/main/laravel-resend-examples)
>
> Laravel 11 examples

> [card] [Python](https://github.com/resend/resend-examples/tree/main/python-resend-examples)
>
> Python examples with Flask, FastAPI, and Django

> [card] [Ruby](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples)
>
> Ruby examples with Sinatra and Rails

> [card] [Go](https://github.com/resend/resend-examples/tree/main/go-resend-examples)
>
> Go examples with Chi and Gin

> [card] [Java](https://github.com/resend/resend-examples/tree/main/java-resend-examples)
>
> Java examples with Javalin and Spring Boot

> [card] [.NET (C#)](https://github.com/resend/resend-examples/tree/main/dotnet-resend-examples)
>
> ASP.NET Minimal APIs and MVC

> [card] [Rust](https://github.com/resend/resend-examples/tree/main/rust-resend-examples)
>
> Rust examples with Axum

> [card] [Elixir](https://github.com/resend/resend-examples/tree/main/elixir-resend-examples)
>
> Elixir examples with Phoenix

## Next.js (TypeScript)

> [card] [Send Email](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/send-email)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/attachments)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/cid-attachments)
>
> Embed inline images using CID

> [card] [React Email](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/react-email)
>
> Send emails with React Email components

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/templates)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/scheduling)
>
> Schedule emails for future delivery

> [card] [Contact Form](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/contact-form)
>
> Contact form with batch send via Server Actions

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/double-optin)
>
> Double opt-in subscription flow

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/inbound)
>
> Receive and process inbound emails

> [card] [Prevent Threading](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/prevent-threading)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/domains)
>
> Create and manage sending domains

> [card] [Automations](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/automations)
>
> Create and manage lifecycle automations

> [card] [Better Auth](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/better-auth)
>
> Email authentication with Better Auth

## Next.js (JavaScript)

> [card] [Send Email](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/send-email)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/attachments)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/cid-attachments)
>
> Embed inline images using CID

> [card] [React Email](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/react-email)
>
> Send emails with React Email components

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/templates)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/scheduling)
>
> Schedule emails for future delivery

> [card] [Contact Form](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/contact-form)
>
> Contact form with batch send via Server Actions

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/double-optin)
>
> Double opt-in subscription flow

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/inbound)
>
> Receive and process inbound emails

> [card] [Prevent Threading](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/prevent-threading)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/domains)
>
> Create and manage sending domains

> [card] [Automations](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/automations)
>
> Create and manage lifecycle automations

> [card] [Better Auth](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/better-auth)
>
> Email authentication with Better Auth

## Express

TypeScript and JavaScript variants available. Links below point to the TypeScript examples.

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/basic-send.ts)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/batch-send.ts)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/with-attachments.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/with-cid-attachments.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/with-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/scheduled-send.ts)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/prevent-threading.ts)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/audiences.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/domains.ts)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/inbound.ts)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/double-optin-subscribe.ts)
>
> Double opt-in subscription flow

## Hono

TypeScript and JavaScript variants available. Links below point to the TypeScript examples.

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/basic-send.ts)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/batch-send.ts)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/with-attachments.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/with-cid-attachments.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/with-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/scheduled-send.ts)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/prevent-threading.ts)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/audiences.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/domains.ts)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/inbound.ts)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/double-optin-subscribe.ts)
>
> Double opt-in subscription flow

## Bun

TypeScript and JavaScript variants available. Links below point to the TypeScript examples.

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/basic-send.ts)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/batch-send.ts)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/with-attachments.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/with-cid-attachments.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/with-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/scheduled-send.ts)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/prevent-threading.ts)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/audiences.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/domains.ts)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/inbound.ts)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/double-optin-subscribe.ts)
>
> Double opt-in subscription flow

## Remix

TypeScript and JavaScript variants available. Links below point to the TypeScript examples.

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send-attachment.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send-cid.ts)
>
> Embed inline images using CID

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send-batch.ts)
>
> Send multiple emails at once

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send-scheduled.ts)
>
> Schedule emails for future delivery

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.domains.ts)
>
> Create and manage sending domains

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.audiences.contacts.ts)
>
> Manage contacts and audiences

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.webhook.ts)
>
> Handle webhook events

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/double-optin.tsx)
>
> Double opt-in subscription flow

> [card] [Inbound](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/inbound.tsx)
>
> Receive and process inbound emails

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/prevent-threading.tsx)
>
> Prevent email threading on Gmail

## Nuxt

TypeScript and JavaScript variants available. Links below point to the TypeScript examples.

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send.post.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send-attachment.post.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send-cid.post.ts)
>
> Embed inline images using CID

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send-batch.post.ts)
>
> Send multiple emails at once

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send-template.post.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send-scheduled.post.ts)
>
> Schedule emails for future delivery

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/domains.post.ts)
>
> Create and manage sending domains

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/nuxt-resend-examples/typescript/server/api/audiences)
>
> Manage contacts and audiences

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/webhook.post.ts)
>
> Handle webhook events

## SvelteKit

TypeScript and JavaScript variants available. Links below point to the TypeScript examples.

> [card] [Send Email](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-attachment)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-cid)
>
> Embed inline images using CID

> [card] [Batch Send](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-batch)
>
> Send multiple emails at once

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-template)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-scheduled)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-prevent-threading)
>
> Prevent email threading on Gmail

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/domains)
>
> Create and manage sending domains

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/audiences)
>
> Manage contacts and audiences

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/double-optin)
>
> Double opt-in subscription flow

> [card] [Webhooks](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/webhook)
>
> Handle webhook events

## Astro

TypeScript and JavaScript variants available. Links below point to the TypeScript examples.

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send-attachment.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send-cid.ts)
>
> Embed inline images using CID

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send-batch.ts)
>
> Send multiple emails at once

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send-scheduled.ts)
>
> Schedule emails for future delivery

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/domains.ts)
>
> Create and manage sending domains

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/astro-resend-examples/typescript/src/pages/api/audiences)
>
> Manage contacts and audiences

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/webhook.ts)
>
> Handle webhook events

## RedwoodJS

TypeScript and JavaScript variants available. Links below point to the TypeScript examples.

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/sendAttachment.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/sendCid.ts)
>
> Embed inline images using CID

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/sendBatch.ts)
>
> Send multiple emails at once

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/sendTemplate.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/sendScheduled.ts)
>
> Schedule emails for future delivery

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/domains.ts)
>
> Create and manage sending domains

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/audiencesContacts.ts)
>
> Manage contacts and audiences

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/webhook.ts)
>
> Handle webhook events

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/doubleOptinSubscribe.ts)
>
> Double opt-in subscription flow

## TanStack Start

TypeScript and JavaScript variants available. Links below point to the TypeScript examples.

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-attachment.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-cid.ts)
>
> Embed inline images using CID

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-batch.ts)
>
> Send multiple emails at once

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-scheduled.ts)
>
> Schedule emails for future delivery

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/domains.ts)
>
> Create and manage sending domains

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/tanstack-resend-examples/typescript/src/routes/api/audiences)
>
> Manage contacts and audiences

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/webhook.ts)
>
> Handle webhook events

## PHP

> [card] [Basic Send](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/send)
>
> Basic, batch, and prevent-threading send

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/attachments)
>
> File attachments and inline images (CID)

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/scheduling)
>
> Schedule emails for future delivery

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/templates)
>
> Send emails using Resend hosted templates

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/double-optin)
>
> Double opt-in subscription flow

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/inbound)
>
> Receive and process inbound emails

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/domains)
>
> Create and manage sending domains

> [card] [Automations](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/automations)
>
> Create and manage lifecycle automations

> [card] [Symfony App](https://github.com/resend/resend-examples/tree/main/php-resend-examples/symfony_app)
>
> Full Symfony web application

## Laravel

> [card] [Email Sending](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/EmailController.php)
>
> Basic, scheduled, attachments, CID, templates, and prevent threading

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/WebhookController.php)
>
> Handle webhook events

> [card] [Inbound Email](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/InboundController.php)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/DoubleOptinController.php)
>
> Double opt-in subscription flow

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/AudienceController.php)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/DomainController.php)
>
> Create and manage sending domains

## Python

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/basic_send.py)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/batch_send.py)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_attachments.py)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_cid_attachments.py)
>
> Embed inline images using CID

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/scheduled_send.py)
>
> Schedule emails for future delivery

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_template.py)
>
> Send emails using Resend hosted templates

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/prevent_threading.py)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/audiences.py)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/domains.py)
>
> Create and manage sending domains

> [card] [Automations](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/automations.py)
>
> Create and manage lifecycle automations

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/inbound.py)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/double_optin_subscribe.py)
>
> Double opt-in subscription flow

> [card] [Flask App](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/flask_app.py)
>
> Full Flask web application

> [card] [FastAPI App](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/fastapi_app.py)
>
> Full FastAPI web application

> [card] [Django App](https://github.com/resend/resend-examples/tree/main/python-resend-examples/django_app)
>
> Full Django web application

## Ruby

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/basic_send.rb)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/batch_send.rb)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/with_attachments.rb)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/with_cid_attachments.rb)
>
> Embed inline images using CID

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/scheduled_send.rb)
>
> Schedule emails for future delivery

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/with_template.rb)
>
> Send emails using Resend hosted templates

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/prevent_threading.rb)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/audiences.rb)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/domains.rb)
>
> Create and manage sending domains

> [card] [Automations](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/automations.rb)
>
> Create and manage lifecycle automations

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/inbound.rb)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples/double_optin)
>
> Double opt-in subscription flow

> [card] [Sinatra App](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/sinatra_app)
>
> Full Sinatra web application

> [card] [Rails App](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/rails_app)
>
> Full Rails web application

## Go

> [card] [Basic Send](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/basic_send)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/batch_send)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/with_attachments)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/with_cid_attachments)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/with_template)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/scheduled_send)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/prevent_threading)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/domains)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/inbound)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/double_optin)
>
> Double opt-in subscription flow

> [card] [Chi App](https://github.com/resend/resend-examples/tree/main/go-resend-examples/chi_app)
>
> Full Chi web framework application

> [card] [Gin App](https://github.com/resend/resend-examples/tree/main/go-resend-examples/gin_app)
>
> Full Gin web framework application

## Java

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/BasicSend.java)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/BatchSend.java)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/WithAttachments.java)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/WithCidAttachments.java)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/WithTemplate.java)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/ScheduledSend.java)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/PreventThreading.java)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/Audiences.java)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/Domains.java)
>
> Create and manage sending domains

> [card] [Automations](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/Automations.java)
>
> Create and manage lifecycle automations

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/Inbound.java)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/DoubleOptinSubscribe.java)
>
> Double opt-in subscription flow

> [card] [Javalin App](https://github.com/resend/resend-examples/tree/main/java-resend-examples/javalin_app)
>
> Full Javalin web framework application

> [card] [Spring Boot App](https://github.com/resend/resend-examples/tree/main/java-resend-examples/spring_boot_app)
>
> Full Spring Boot application

## .NET (C#)

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/BasicSend.cs)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/BatchSend.cs)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/WithAttachments.cs)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/WithCidAttachments.cs)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/WithTemplate.cs)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/ScheduledSend.cs)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/PreventThreading.cs)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/Audiences.cs)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/Domains.cs)
>
> Create and manage sending domains

> [card] [Automations](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/Automations.cs)
>
> Create and manage lifecycle automations

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/Inbound.cs)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/DoubleOptinSubscribe.cs)
>
> Double opt-in subscription flow

> [card] [Minimal API App](https://github.com/resend/resend-examples/tree/main/dotnet-resend-examples/MinimalApiApp)
>
> ASP.NET Minimal API application

> [card] [MVC App](https://github.com/resend/resend-examples/tree/main/dotnet-resend-examples/MvcApp)
>
> ASP.NET MVC application

## Rust

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/basic_send.rs)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/batch_send.rs)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/with_attachments.rs)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/with_cid_attachments.rs)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/with_template.rs)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/scheduled_send.rs)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/prevent_threading.rs)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/audiences.rs)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/domains.rs)
>
> Create and manage sending domains

> [card] [Automations](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/automations.rs)
>
> Create and manage lifecycle automations

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/inbound.rs)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/double_optin_subscribe.rs)
>
> Double opt-in subscription flow

> [card] [Axum App](https://github.com/resend/resend-examples/tree/main/rust-resend-examples/axum_app)
>
> Full Axum web framework application

## Elixir

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/basic_send.exs)
>
> Basic email sending

> [card] [Batch Send](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/batch_send.exs)
>
> Send multiple emails at once

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/with_attachments.exs)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/with_cid_attachments.exs)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/with_template.exs)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/scheduled_send.exs)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/prevent_threading.exs)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/audiences.exs)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/domains.exs)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/inbound.exs)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/elixir-resend-examples/examples/double_optin)
>
> Double opt-in subscription flow

> [card] [Phoenix App](https://github.com/resend/resend-examples/tree/main/elixir-resend-examples/phoenix_app)
>
> Full Phoenix web framework application


# Resend Forge
Source: https://resend.com/docs/forge

Send and receive your email through Resend's new infrastructure.

Resend Forge is Resend's next-generation email infrastructure.

It's faster than the old engine on every percentile and has best-in-class delivery rates.

It's fully managed by Resend, using our own IPs and our own sending and receiving engine, with no third party in the middle. That gives us full visibility into every hop, so we can better help you with any deliverability or support request.

You can read the [full announcement](https://resend.com/features/forge) on our website.

> [!NOTE]
>
> Your domain keeps sending at all times while we verify the new DNS record, and
> nothing else changes: your API calls, SMTP credentials, and webhooks all stay
> the same.

## Activate Resend Forge

Activating Forge requires one CNAME record for sending domains. In the case of receiving, you will need to update one MX record. No code changes are required in either case.

**1. Open the activation page**

1. Go to [Domains](https://resend.com/domains) and select your domain.
2. Under **Configuration**, click **Activate Resend Forge**.

   ![The Activate Resend Forge section in the domain's Configuration tab](https://mintcdn.com/resend/vVB0a1rP7wPQimDb/images/resend-forge-configuration.png?fit=max\&auto=format\&n=vVB0a1rP7wPQimDb\&q=85\&s=51074ad46b034f9d9580debd2fa48f47)

**2. Choose the Return-Path**

> [!NOTE]
>
> Receiving-only domains don't need a Return-Path, so you will only see the
> record updates your domain needs.

Forge uses a new subdomain as the Return-Path (e.g. `mail.yourdomain.com`).
We suggest an available one by default. You can type a different one, and the
field checks that the subdomain is free before you continue.

Click **Activate Forge**.

![The Return-Path step of the Activate Resend Forge page](https://mintcdn.com/resend/vVB0a1rP7wPQimDb/images/resend-forge-return-path.png?fit=max\&auto=format\&n=vVB0a1rP7wPQimDb\&q=85\&s=d17023e3ae83a156ca79cd752aef9405)

**3. Add the CNAME record**

If your DNS provider supports [Domain Connect](#domain-connect), click **Auto
configure** and authorize Resend to add the record for you. The domain
verifies on its own after that.

Otherwise, click **Manual setup** and add the CNAME record shown on the page
at your DNS provider, then click **I've added the records**. Your existing
DNS records stay untouched. Don't remove them.

![The DNS Records step showing the CNAME record to add at your DNS provider](https://mintcdn.com/resend/vVB0a1rP7wPQimDb/images/resend-forge-dns-record.png?fit=max\&auto=format\&n=vVB0a1rP7wPQimDb\&q=85\&s=ac176de76f2f24545a7437bec9c4ca68)

> [!WARNING]
>
> Pay attention to the record's proxy status. If you use Cloudflare, set the
> record to **DNS only**, not proxied (the cloud icon is gray, not orange).
> Proxied records don't resolve as CNAMEs, so verification will fail.

**4. Verify**

Once the record verifies, the Forge section of your domain's page shows an
**Enabled** tag. From there, Resend gradually moves your sending onto Forge to
keep deliverability high, and the share of your email going through Forge
grows over time. Once your email is routing through Forge, the tag changes to
**Active**.

## Domain Connect

[Domain Connect](https://www.domainconnect.org/) lets Resend add the Forge
records to your DNS for you. If your domain's DNS provider supports it, the DNS
Records step shows an **Auto configure** button.

1. Click **Auto configure**.
2. Sign in to your DNS provider in the window that opens and authorize the change.
3. Resend adds the CNAME record and starts verifying it. You're sent back to your domain's page.

Domain Connect is only available on this page for domains that already existed
before activating Forge. If you prefer to add the record yourself, click
**Manual setup**.

## Troubleshooting

If the Forge record doesn't verify, these are some common troubleshooting methods.

> [accordion] My DNS provider rejects the CNAME record.
>
> A CNAME can't coexist with other records at the same name. If the subdomain
> you chose already has records (e.g., an A, TXT, or MX record), pick a
> different Return-Path: under **Configuration**, click **Finish Forge
> setup**, then click **Change** next to the Return-Path and choose another
> name.

> [accordion] I added the record but it never verifies.
>
> DNS changes can take up to 72 hours to propagate, though they're usually much
> faster. Check that the record name and value match exactly what the Dashboard
> shows, and rule out copy and paste errors. Some DNS providers auto-append
> your domain name to record values; if the record value shows your domain
> twice, add a trailing period to the value.
>
> If you use Cloudflare, check the record's proxy status: it must be **DNS
> only**, not proxied (the cloud icon is gray, not orange). Proxied records
> don't resolve as CNAMEs, so verification will fail.
>
> Also confirm you added the record at the DNS provider that actually controls
> your domain's DNS. If your DNS is managed in multiple places (e.g., your
> registrar and Cloudflare), run a nameserver lookup with a tool like
> [dns.email](https://dns.email) to see which provider to use.

> [accordion] The record shows as failed. How do I restart verification?
>
> 1. Open your domain's page. Under **Configuration**, click **Finish Forge setup**.
> 2. The page shows your CNAME record again. Confirm it matches what's in your DNS provider and click **I've added the records** to restart verification.
>
> Unless you change the Return-Path, the record stays the same. You're
> re-verifying the existing record and don't need to change anything at your DNS
> provider.

> [accordion] The Activate Resend Forge button is disabled.
>
> Hover over the button to see the reason. Your domain doesn't meet one of the
> [requirements](#requirements) below.

## Requirements

* Domains on a Dedicated IP can't activate Forge. Contact [support@resend.com](mailto:support@resend.com).
* Open and click tracking aren't supported on Forge yet. You can activate Forge on a domain that has tracking turned on, but its email keeps going through the current infrastructure until you turn tracking off.

## FAQ

> [accordion] What happens if Forge has an incident or can't deliver an email?
>
> Your email still goes out. If Forge can't complete a delivery, we route it
> through the engine Resend has used for years. The fallback is automatic and
> you don't need to do anything.

> [accordion] How long does Forge retry a delayed email?
>
> When the receiving server asks to try again later, for example with
> greylisting or a temporary rate limit, Forge keeps retrying for up to 48
> hours. Other temporary failures go back to the engine Resend has used for
> years, which retries for up to 14 hours. An email that still isn't accepted
> when its retry window ends is marked as `bounced`.

> [accordion] Do I need to change my code, SMTP settings, or webhooks?
>
> No. Forge sits behind the same send path, so your API calls, SMTP
> credentials, and webhook events keep working exactly as today.

> [accordion] Why does Forge need a new Return-Path subdomain?
>
> The Return-Path is the address receivers use to return bounces and to check
> SPF. Forge delivers from infrastructure Resend owns, so the CNAME points
> that subdomain at Forge. This keeps SPF aligned with your domain and lets us
> process bounces. Your existing DNS records stay as they are.

> [accordion] Which region does Forge send from and receive at?
>
> Forge runs only in North Virginia (`us-east-1`). Data residency is the same
> as for every other region. See [Data
> Residency](/docs/dashboard/domains/regions#data-residency) for details.

> [accordion] I have activated Forge but I'm still seeing the old headers
>
> The **Enabled** tag means your domain is ready for Forge. Resend moves your
> sending onto Forge gradually, so for a while part of your email still goes
> out the usual way. You don't need to do anything.


# Can I merge accounts or teams?
Source: https://resend.com/docs/guides/account/can-i-merge-accounts-or-teams

Teams cannot be merged, but you can move people, domains and your plan onto the one team you want to keep.

No, teams can't be merged. Each team has its own API keys, billing, and usage, and API keys. Email history and plans can't be moved from one team to another. To consolidate teams, pick the team you want to keep and move people and domains into it.

> [!NOTE]
>
> Email history stays with the team it was sent from. Before you delete a team,
> an admin can download emails, logs, domains, contacts, and other data as CSV
> with the **Export** button on those pages.

## Consolidate onto one team

**1. Choose the team to keep**

If it needs a paid plan, select that team and upgrade it from
[Billing](https://resend.com/settings/billing).

**2. Invite your teammates**

In [Team](https://resend.com/settings/team), click **Invite**, enter each
person's email address and choose **Admin** or **Member**. Those with access
to additional accounts can switch between teams using the switcher in the
top left corner.

**3. Move each domain**

Delete each domain in the old team and re-add each domain to the team you
want to keep. Deleting a domain can't be undone.

**4. Create new API keys**

Once your domains are verified on the kept team, create keys from [API
keys](https://resend.com/api-keys) and update your applications.

**5. Retire the old teams**

Cancel any plan on the teams you no longer need. Then delete each team from
[the team settings](https://resend.com/settings/team). Deleting the team
removes all its data and isn't reversible. For more help, see [How to delete
your Resend team](/docs/knowledge-base/how-can-i-delete-my-team).

## If you can no longer reach the other team

If a domain sits on a team you no longer have access to, add the domain on the team you want to keep. Resend will prompt you to start a claim, which proves ownership with a TXT record. See [Claiming a domain](/docs/dashboard/domains/claim) for more information.

## Several products or clients in one team

One team can serve several products or clients. See the [multi tenant setup guide](/docs/knowledge-base/setting-up-resend-for-multi-tenants) for recommended setup.

## Additional support

If a domain claim is blocked or you are unsure which team to keep, contact [Resend support](https://resend.com/help) for assistance.


# How to recover access to a team you can no longer sign in to
Source: https://resend.com/docs/guides/account/how-to-recover-access-to-a-team

How to get back into a Resend team when the email you signed in with no longer works or no admin is left on the team.

If the email you signed in with no longer works (e.g., a former employee's mailbox, a deleted Google account, an expired domain), or no admin is left on the team, use the case below that matches to recover team access:

* [An admin can still sign in](#an-admin-can-still-sign-in)
* [No admin can sign in](#no-admin-can-sign-in)
* [You only need the domain](#you-only-need-the-domain)

> [!NOTE]
>
> Support cannot change the email address on an existing login, so the fix is
> always to give a login you control access to the team.

## An admin can still sign in

An admin can fix your access without contacting support:

1. Signed in as an admin, go to [Team](https://resend.com/settings/team) and click **Invite**.
2. Enter an email address you control and choose the **Admin** role.
3. Accept the invite.

If you are already a member, an admin can change your role instead. See [Managing Teams](/docs/dashboard/settings/team).

> [!TIP]
>
> Always transfer admin access to another member if you foresee losing access to
> your email account. Invite the new admin from
> [Team](https://resend.com/settings/team), then leave the team.

## No admin can sign in

Support can restore access after you prove you own a domain on the team.

1. If you aren't a member of the team, sign up for a new Resend account with an address you control. If the old login used a Google account that no longer exists, sign up with email rather than Google.
2. [Contact support](https://resend.com/help). Include:
   * A domain that is on the team.
   * The email of the Resend account that should get access, and whether it's already a member of the team.
3. Support replies with a verification value that is unique to your request. Add a `TXT` record on that domain with the host `verification` and that value. The host must be exactly `verification`.
4. Reply to the support conversation with the name of the domain where you added the `TXT` record.

Once ownership is verified, support gives your account admin access to the team. Nothing on the team is changed, revoked or deleted in the process.

If you still control the old mailbox but the login asks for an MFA code you don't have access to, see our [Locked out by MFA](/docs/guides/account/locked-out-by-mfa) support article.

## You only need the domain

You can add the domain to a team you control and prove ownership with a self serve claim. See [Claiming a domain](/docs/dashboard/domains/claim). A claim moves the domain only and doesn't give you access to the old team. Safety checks can block a claim, for example when the domain was recently active on the other team.

Please [reach out to support](https://resend.com/help) for help with a domain claim.


# Locked out by MFA
Source: https://resend.com/docs/guides/account/locked-out-by-mfa

How to use your MFA recovery code when you lose your authenticator app, and how Resend support verifies ownership when you have no recovery code.

If you turned on multi factor authentication (MFA) and can no longer get a code from your authenticator app, use your recovery code to turn MFA off and sign in. If you don't have a recovery code, Resend support can remove MFA from your login after verifying that you own the account.

## Check the code first

If your authenticator app still has a Resend entry but the codes are rejected:

* Use the entry your authenticator app created when you turned on MFA in Resend.
* Set your phone's clock to update automatically. A phone clock that is off produces codes that don't match.

## Reset MFA with your recovery code

Your recovery code is the single code Resend showed when you turned on MFA. It has ten characters split by a dash, in the format `XXXXX-XXXXX`.

**1. Turn off MFA with your recovery code**

Using your recovery code turns off MFA and allows you to sign in with your usual method.

> [!NOTE]
>
> If you also lost access to the email address you sign in with, see our
> [recover access to a team](/docs/guides/account/how-to-recover-access-to-a-team)
> support article.

To use your recovery code, sign in with your usual method and enter your recovery code when Resend asks for your authenticator code. ([View help](#if-you-do-not-have-a-recovery-code) if you do not have a recovery code.)

The recovery code works once. Using it also:

* Signs out every other active session on your account.
* Sends an email titled "Your Resend two-factor authentication was reset" to your email address.

Removing MFA only removes the authenticator factor. The domains and API keys on the account stay untouched.

**2. Turn on MFA again**

Enable MFA on again from your [Profile](https://resend.com/profile) with your new device. Resend shows you a new recovery code when you do. Save it before you close the dialog. See [how to add MFA](/docs/knowledge-base/how-can-i-add-mfa) for more details.

If you receive that email and did not use your recovery code, reset your password and [contact support](https://resend.com/help) immediately.

## MFC recovery code security

Resend shows the recovery code once, when you turn on MFA, and does not show it again. Copy it and store it somewhere other than the device that holds your authenticator app, such as a password manager.

## What does not remove MFA

* **A password reset.** After the reset, sign in still asks for the authenticator code.
* **Another team member.** MFA belongs to each login, not to the team. Another member, including an admin, cannot reset or disable it for you.

## If you do not have a recovery code

You can ask support to remove MFA for you.

1. Contact support from [Help](https://resend.com/help). In your first message, include:
   * The email address you sign in with.
   * A domain that is already on the account.
   * A note if you never turned on MFA yourself, so support can review the account before anything changes.

2. Support will reply with a verification value that is unique to your request. Add it as a DNS record on that domain to prove you own it:

   | Host | Type | Value |
   | - | - | - |
   | `verification` | `TXT` | The value from support |

   Most DNS providers display this record as `verification.yourdomain.com`. The host must be exactly `verification`.

3. Once the record is in place, reply the support conversation and name the domain with the verification record.

If there are no domains on the account, communicate with Support to verify ownership another way.


# Send emails with Attio and Resend
Source: https://resend.com/docs/guides/attio-integration

Connect Resend to Attio to create contacts, add people to segments, and send emails from workflows.

[Attio](https://attio.com) is a customer relationship management platform. The Attio [Resend app](https://attio.com/apps/resend) connects Attio workflows and person records to Resend. You can create contacts, add people to segments, and send plain text or template emails without leaving Attio.

For example, when a deal is marked Closed Won, a workflow can create a contact for the buyer, add that person to a segment, and send a welcome email.

The app is available on every Attio plan. A workspace admin connects one API key for the whole workspace. There isn't a separate connection per member. After the app is connected, every member can run the workflow steps and the record action.

## Connect Resend

**1. Create an API key**

[Create an API key](https://resend.com/api-keys) in Resend.

* Use **Full access** when workflows create contacts or add people to segments.
* Use **Sending access** when you only send email. That permission can't create contacts or update segments.

You can change the permission later in the [API keys Dashboard](/docs/dashboard/api-keys/introduction).

**2. Install the app in Attio**

1. In Attio, click your workspace name, then click **Apps and integrations**.
2. Search for **Resend**, open the app, and click **Install**.
3. Under **Workspace connection**, click **Connect**.
4. Paste the API key and click **Add connection**.

Attio doesn't check the key when you connect it. An invalid key or a missing permission appears when a step or the record action runs.

Attio documents this setup in the [Resend app article](https://attio.com/help/reference/apps/communication-apps/resend-app).

## Use Resend in a workflow

Add these steps to an [Attio workflow](https://attio.com/help/reference/automations/workflows/create-a-workflow).

### Create contact

Creates a Resend contact from an email address.

* **Email:** The contact's email address. Required.
* **Full name:** The contact's name. Optional.
* **Unsubscribed:** Turn this on to unsubscribe the contact from all Broadcasts. You can't pass a variable for this field.

On success, the step returns the contact ID. Pass that ID into a later step, such as Add contact to segment.

Email identifies the contact in Resend. Run the step again with the same email and Resend updates that contact's name and subscription status. It doesn't create a second contact.

### Add contact to segment

Adds an existing Resend contact to a [segment](/docs/dashboard/contacts/manage-segments).

* **Segment:** The segment to add the contact to. Search the list and pick one. You can't pass a variable for this field. Required.
* **Contact:** The contact to add. Search for a contact, or pass a contact ID from an earlier step. Required.

On success, the step returns the segment ID.

Chain this step after Create contact. Pass that step's contact ID into the contact field.

### Send email

Sends an email through Resend as plain text or from a published [template](/docs/dashboard/templates/introduction).

* **From:** The sending address. Use an address on a [verified domain](/docs/add-a-domain). Required.
* **To:** The recipient's email address. Required.
* **Subject:** The email subject. Required.
* **Plain text:** The email body as plain text.
* **Template:** A published template to send instead of plain text.
* **Template variables:** When you pick a template in the step, Attio adds a text field for each variable that template declares.
* **From name:** The name shown next to the From address. Optional.
* **CC:** Extra recipients to copy. Optional.
* **BCC:** Extra recipients to blind copy. Optional.
* **Reply to:** The address that receives replies. Optional.
* **Schedule:** When to send the email. Leave this empty to send right away. Optional.
* **Tags:** Name and value pairs that label the email in Resend. Optional.
* **Topic:** The [topic](/docs/dashboard/contacts/manage-topics) for this email. Pick it from the list. You can't pass a variable for this field. Optional.
* **Attachments:** Files to attach. Each file needs a filename and a remote file URL. Optional.

Fill in plain text or a template. If you select a template, Attio ignores the plain text body.

On success, the step returns the email ID. Run the same step again and Attio doesn't send a second copy.

> [!NOTE]
>
> The From address has to use a domain you verified in Resend. With the test
> sender `onboarding@resend.dev`, you can only email your own address. [Add a
> domain](/docs/add-a-domain) to email anyone else.

> [!NOTE]
>
> If you edit a template in Resend after you configure the step, and the
> template needs a variable you haven't set, the step fails and names the
> missing variable. Open the step and fill in that variable.

## Add a person to a segment

You can add one person to a Resend segment from their record, without a workflow.

1. On a person record, open the record menu and click **Add to segment**.
2. If the person has more than one email address, choose which address to use. With one address, Attio shows the field and you can't change it.
3. Select a segment.
4. Click **Add to segment**.

Attio looks up the contact in Resend by email. If no contact exists for that address, Attio creates one and adds it to the segment. If the contact already exists, Attio adds that contact to the segment.

If the action fails, Attio shows the error from Resend and keeps the dialog open so you can correct the issue and try again.

## Fix a failed step

### The key doesn't have permission

An invalid or revoked key fails as unauthorized. A valid key that lacks permission for the action fails with a permission error.

Reconnecting the same key keeps the same permissions. Open the key in the [API keys Dashboard](/docs/dashboard/api-keys/introduction) and grant the permission the action needs, or create a new key and connect that one.

Create contact and Add contact to segment need **Full access**. Send email works with **Sending access**.

### Some fields can't take a variable

The segment on Add contact to segment, and the topic on Send email, come from a list in the step. You pick them when you configure the step. The contact on Add contact to segment can use a variable. The unsubscribed field on Create contact can't use a variable either.


# Building an OAuth client for Resend
Source: https://resend.com/docs/guides/building-a-resend-oauth-client

Implement an OAuth 2.1 + PKCE client against the Resend API, from scratch or with a library.

Resend implements OAuth 2.0 and 2.1, including Proof Key for Code Exchange (PKCE) for authorization code exchanges. A client's `client_id` comes from one of three places:

1. Pre-registration: Resend issues a fixed `client_id`, plus a `client_secret` if the client has a backend.
2. [Client ID Metadata Document](#client-id-metadata-documents) (CIMD): the `client_id` is the HTTPS URL of a JSON document you host, which Resend fetches to read the client's metadata.
3. Dynamic Client Registration (DCR): the client registers itself at runtime via POST /oauth/register and is issued a `client_id` then.

**Prefer CIMD over DCR:** it gives the client one identity across every install instead of a new registration each time, and the consent screen can name the host that published the document rather than a name the client picked for itself.

Resend supports both **public** and **confidential** clients. PKCE is required on every authorization code exchange regardless of type:

* **Public clients** authenticate with PKCE alone. Register them with `token_endpoint_auth_method: "none"` (the default), or declare that value in the metadata document. Use a public client when it can't keep a secret, such as native apps, CLIs, and single-page apps.
* **Confidential clients** additionally authenticate at the token and revocation endpoints. A registered client presents a `client_secret`: register it with `token_endpoint_auth_method: "client_secret_basic"` (or `client_secret_post`) to have Resend issue the secret. A CIMD client can't carry a secret, since its document is world-readable, so it signs a JWT with its own private key instead ([`private_key_jwt`](#private-key-jwt)). Use a confidential client when it has a backend that can keep a credential private, such as a server-side web app.

Because Resend does not offer self-service verification or domain-ownership checks yet, pre-register remote third-party clients rather than registering them dynamically, but you can register them with the same register endpoint.

The Resend dashboard hosts the login and consent screen. Your client only needs to open the authorization URL in a browser and handle the callback. You don't build any consent UI yourself.

## Recommended implementation paths

The standard case is registering beforehand, and the worked examples below use it. A metadata document is the next best thing for clients that can't predict their own deployment details ahead of time, like an MCP server: it works for hosted apps and local tools alike, and one document serves every install. Register dynamically only when the client can't host a document.

Also decide whether the client is public or confidential. A client running entirely on the user's machine, such as a native app, CLI, or single-page app, can't hide a secret, so register it as public (`none`). A client with a server-side backend should register as confidential (`client_secret_basic`) and keep the issued `client_secret` out of any user-facing code. A CIMD client makes the same choice in its document: `none` for a public client, or [`private_key_jwt`](#private-key-jwt) for a confidential one. The [pre-registered remote client](#pre-registered-remote-client) section below covers the confidential path, and the [local client](#local-client) section covers the public one.

## Scopes

Use the smallest scope that works for your integration:

* `emails:send` is enough for send-only routes, such as `POST /emails`, `POST /email`, `POST /emails/sending`, `POST /email/sending`, and `POST /broadcasts/:broadcastId/send`.
* `full_access` is required for other API routes.

A client that omits `scope` gets both scopes by default, whether it registered dynamically or declared no `scope` in its metadata document. Pass `scope` explicitly during registration and authorization instead of relying on that default.

## Request encoding and `resource`

Dynamic client registration uses JSON, and so does a metadata document. The token and revocation endpoints accept both JSON and `application/x-www-form-urlencoded`, but prefer form encoding for `/oauth/token` and `/oauth/revoke`, since that's what most OAuth libraries send by default.

Resend does not support RFC 8707 resource indicators yet. Don't send or rely on `resource` in authorization or token requests. It's accepted but ignored.

## Generating PKCE values and state

Before starting the authorization request, generate three values:

* `code_verifier`: a high-entropy random string kept only by the client. See
  [Token](/docs/api-reference/oauth/token#pkce) for the length and character set it
  must use.
* `code_challenge`: the base64url-encoded SHA-256 hash of the `code_verifier`.
* `state`: a high-entropy random string used to bind the callback to the request that started the flow.

The `code_verifier` is sent only during the token exchange. The `code_challenge` is sent during authorization. The `state` is sent during authorization and must come back unchanged on the callback.

```javascript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { createHash, randomBytes } from 'node:crypto';

function base64url(input) {
  return Buffer.from(input).toString('base64url');
}

const codeVerifier = base64url(randomBytes(64));
const codeChallenge = base64url(
  createHash('sha256').update(codeVerifier).digest(),
);
const state = base64url(randomBytes(24));
```

For a remote client, store `state` and `codeVerifier` server-side before redirecting the user to us. For a local client, keep them in memory while the temporary callback server is running.

## Client ID Metadata Documents

Instead of registering, host a JSON document that describes the client and pass its HTTPS URL as the `client_id`:

```
GET /oauth/authorize?client_id=https%3A%2F%2Fexample.com%2Foauth%2Fclient.json&response_type=code&...
```

Resend fetches that URL, reads the client metadata from it, and runs the rest of the flow exactly as it does for a registered client. There's no registration call and no issued `client_id` to store. The client hardcodes its own document URL, and sends the same value as `client_id` at `/oauth/token` and `/oauth/revoke`.

This follows the [OAuth Client ID Metadata Document](https://datatracker.ietf.org/doc/draft-ietf-oauth-client-id-metadata-document/) draft. The rules below are the parts specific to Resend.

Host the document on a site you control, whatever the client is. A hosted app serves it next to the app and lists its own `https` callback. A CLI or desktop app serves it on the vendor's website and lists loopback callbacks, since the document only has to name the client, not run it.

### The document

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "client_id": "https://example.com/oauth/client.json",
  "client_name": "Example App",
  "client_uri": "https://example.com",
  "logo_uri": "https://example.com/logo.png",
  "redirect_uris": ["https://example.com/oauth/callback"],
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"],
  "token_endpoint_auth_method": "none",
  "scope": "emails:send"
}
```

The fields are the [registration](/docs/api-reference/oauth/register) fields, with extra rules:

| Field | Rule |
| - | - |
| `client_id` | Required. Must equal the document's own URL, character for character. |
| `client_name` | Required, 1–200 characters. |
| `redirect_uris` | Required, 1 to 10 entries. An `https` URI must be on the same host as the document. See [Redirect URIs](#redirect-uris-in-a-document). |
| `token_endpoint_auth_method` | `none` (or omitted) for a public client, or `private_key_jwt`. A document is public, so it can't authenticate with a secret. |
| `client_secret` | Must be absent. |
| `jwks_uri` | Required with `private_key_jwt`, and must be absent otherwise. Same URL rules as the document URL, on the same host as the document. |
| `jwks` | Must be absent. Publish the key set at `jwks_uri` instead. |
| `token_endpoint_auth_signing_alg` | Optional, with `private_key_jwt` only. One of `RS256`, `PS256`, or `ES256`. When set, assertions signed with any other algorithm are rejected. |
| `grant_types` | Must include `authorization_code`. Values Resend doesn't support are ignored rather than rejected. |
| `response_types` | If present, `["code"]` only. |
| `scope` | Space-delimited, and every value must be [supported](#scopes). Pass it explicitly: an omitted `scope` gives the client both scopes. |
| `logo_uri` | Optional, `http` or `https`. Shown on the consent screen only when it's served from the same host as the document. |
| `client_uri` | Optional. Read but not otherwise used. |

Apart from `grant_types`, a declaration Resend can't honor fails the whole document rather than being dropped from it. A client that declares `client_secret_basic`, for instance, gets an error rather than being downgraded to an unauthenticated one.

### The document URL

The URL is the client's identity, and it's compared as an exact string with no normalization. Serve the document at a URL that survives a parse-and-serialize round trip: lowercase host, no explicit `:443`, no `.` or `..` segments. It must use `https`, have a path (`https://example.com` alone won't do), and carry no fragment and no userinfo. Maximum 2048 characters.

Treat the URL as permanent. Moving the document makes a different client, and every user has to authorize again.

### Redirect URIs in a document

A document proves that you control its host, and nothing else:

* An `https` redirect URI must be on the same host as the document URL. A document at `https://example.com/oauth/client.json` can't name a callback on `app.example.net`.
* Loopback `http` URIs (`127.0.0.1`, `localhost`, `[::1]`) are exempt. A loopback address names the user's own machine rather than a publisher, so there's nothing to compare. Port variance works the same way it does for a registered client.
* Private-use URI schemes (e.g. `cursor://`) are exempt too, since they carry no web host at all.

### Private key JWT

A CIMD client with a backend can authenticate with a key pair instead of a secret, following [RFC 7523](https://datatracker.ietf.org/doc/html/rfc7523). The private key never leaves the client, so it can live in a hardware security module, and Resend only ever sees the public key.

Declare it in the document, and publish the public key set at `jwks_uri`, on the same host:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "client_id": "https://example.com/oauth/client.json",
  "client_name": "Example App",
  "redirect_uris": ["https://example.com/oauth/callback"],
  "grant_types": ["authorization_code", "refresh_token"],
  "token_endpoint_auth_method": "private_key_jwt",
  "token_endpoint_auth_signing_alg": "ES256",
  "jwks_uri": "https://example.com/oauth/jwks.json",
  "scope": "emails:send"
}
```

The key set is a standard JWK Set (`{"keys": [...]}`). Give each key a `kid` and put it in the JWT header, so Resend can pick the right key. Resend fetches the key set without following redirects, with a 16 KB limit and a 5 second timeout.

On every call to `/oauth/token` and `/oauth/revoke`, send a newly signed JWT in place of a secret:

```
client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
client_assertion=<signed JWT>
```

| Part | Value |
| - | - |
| `alg` (header) | `RS256`, `PS256`, or `ES256`, matching `token_endpoint_auth_signing_alg` when it's declared. |
| `kid` (header) | The `kid` of a key in the key set. |
| `iss` and `sub` | Both the document URL, the same value as `client_id`. |
| `aud` | `https://api.resend.com`. |
| `jti` | A unique random value. Each one is accepted once, so a replayed assertion fails. |
| `exp` | Required, at most 10 minutes ahead. A minute is plenty. |

`client_id` can be omitted from the request body, since the assertion carries it.

To rotate a key, publish the new key next to the old one, then start signing with the new `kid`. Resend refetches the key set when it sees a `kid` it doesn't know, at most once every 30 seconds, so wait 30 seconds after publishing before switching. Then remove the old key.

An ES256 signature from an HSM or a cloud KMS usually comes back DER-encoded. Convert it to the raw 64-byte `R || S` form a JWT expects before base64url-encoding it.

### Hosting and caching

Resend fetches the document when a browser hits `/oauth/authorize`.

* Redirects aren't followed. Serve the document at the exact URL with a `2xx`.
* 5 KB maximum, 5 second timeout. A real document is a few hundred bytes.
* The document must be reachable. A fetch that fails, or a document that doesn't validate, fails the authorization with `invalid_client`. Resend won't fall back to an older copy, since a stale document can name a redirect URI you no longer control.
* `cache-control: max-age` is honored, clamped between 5 minutes and 24 hours. A document sent with `no-store` still gets the 5-minute floor.

Only `/oauth/authorize` fetches. Token, refresh, and revoke requests use the copy Resend already holds, so a document that's briefly unreachable doesn't break clients that already have a grant.

Because of the 5-minute floor, allow time for an edit to take effect. If a CDN caches the file too, the two windows stack.

### On the consent screen

Resend has no self-service verification yet, so a CIMD client is unverified. The consent screen headlines the document's host rather than `client_name`, since the host is the part Resend can check. `client_name` is shown as the client's own claim about itself.

Being unverified affects errors too. Once `client_id` and `redirect_uri` are validated, `/oauth/authorize` redirects an error back to the callback only when the target is a loopback address, a private-use scheme, or a verified client. An unverified `https` callback gets a JSON error instead, which stops the endpoint from being used as an open redirect. Handle both.

## Pre-registered remote client

A remote client must use an HTTPS redirect URI owned by the app, for example `https://example.com/oauth/callback`.

Because a remote client has a backend that can keep a secret, register it as confidential: pass `token_endpoint_auth_method: "client_secret_basic"` and store the `client_secret` Resend returns. That secret is shown only once at registration, so persist it securely and never expose it in browser or client-side code. It's then presented on every token and revocation call, in addition to PKCE.

For remote apps, you can still use [POST /oauth/register](/docs/api-reference/oauth/register) manually while we don't have a central place in the app to create clients.

```mermaid theme={"theme":{"light":"github-light","dark":"vesper"}}
sequenceDiagram
    autonumber
    participant C as App backend
    participant B as User browser
    participant AS as Resend OAuth API
    participant D as Resend dashboard

    Note over C: Generate PKCE values and state<br>Store alongside the user's session

    C->>B: 302 redirect to /oauth/authorize URL
    B->>AS: GET /oauth/authorize<br>client_id, redirect_uri, scope,<br>state, code_challenge
    AS-->>B: 302 redirect to dashboard consent URL
    B->>D: User reviews and approves request
    D-->>B: 302 redirect_uri with code + state
    B->>C: Callback with code + state

    Note over C: Verify state against the stored session value

    C->>AS: POST /oauth/token<br>Basic auth (client_id + client_secret)<br>grant_type=authorization_code<br>code, redirect_uri, code_verifier
    AS-->>C: access_token + refresh_token
```

**1. Load the pre-issued client\_id and client\_secret**

**2. Generate PKCE and state**

`code_verifier`, `code_challenge`, and `state`. See
[above](#generating-pkce-values-and-state).

**3. Store state and code\_verifier server-side**

Tie them to the user's session.

**4. Redirect the user's browser to /oauth/authorize**

**5. Handle the callback on the app's backend**

**6. Reject invalid callbacks**

A missing `code`, mismatched or missing `state`, or an `error` query
parameter should all be treated as failures.

**7. Exchange the code server-side**

Use the original `code_verifier`, and present the `client_secret` via HTTP
Basic auth.

**8. Store the refresh token securely**

**9. Serialize refreshes**

Atomically replace the stored refresh token after every refresh.

Example authorization URL:

```
GET /oauth/authorize?client_id=550e8400-e29b-41d4-a716-446655440000&response_type=code&redirect_uri=https%3A%2F%2Fexample.com%2Foauth%2Fcallback&scope=emails%3Asend&state=STATE_VALUE&code_challenge=CODE_CHALLENGE_VALUE&code_challenge_method=S256 HTTP/1.1
Host: api.resend.com
```

Example code exchange. The `-u` flag sends the `client_id` and `client_secret` as HTTP Basic auth, so `client_id` isn't repeated in the body:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/token' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -u '550e8400-e29b-41d4-a716-446655440000:CLIENT_SECRET' \
     -d 'grant_type=authorization_code&code=AUTHORIZATION_CODE&redirect_uri=https%3A%2F%2Fexample.com%2Foauth%2Fcallback&code_verifier=CODE_VERIFIER_VALUE'
```

## Local client

A local client must use a loopback redirect URI or a private-use URI scheme, per RFC 8252. Prefer `127.0.0.1` with a random local port, for example `http://127.0.0.1:49152/oauth/callback`. A native app the operating system routes to can use its own scheme instead, such as `cursor://oauth/callback`.

Loopback redirect URIs allow port variance, whether they come from registration or from a metadata document. The host, path, and query string must still match, and `localhost` and `127.0.0.1` count as different hosts. For example, a client can declare `http://127.0.0.1/oauth/callback` and later authorize with `http://127.0.0.1:49152/oauth/callback`.

The sequence below registers dynamically. With a [metadata document](#client-id-metadata-documents), skip the registration step: the `client_id` is the document's URL, and the loopback redirect URI is listed in the document.

```mermaid theme={"theme":{"light":"github-light","dark":"vesper"}}
sequenceDiagram
    autonumber
    participant C as Local client
    participant B as User browser
    participant AS as Resend OAuth API
    participant D as Resend dashboard

    Note over C: Bind loopback callback server<br>Generate PKCE values and state

    C->>AS: POST /oauth/register<br>loopback redirect_uri, minimum scope
    AS-->>C: client_id

    C->>B: Open /oauth/authorize URL
    B->>AS: GET /oauth/authorize<br>client_id, redirect_uri, scope,<br>state, code_challenge
    AS-->>B: 302 redirect to dashboard consent URL
    B->>D: User reviews and approves request
    D-->>B: 302 redirect_uri with code + state
    B->>C: Callback with code + state

    Note over C: Verify state, then close the server

    C->>AS: POST /oauth/token<br>grant_type=authorization_code<br>code, redirect_uri, code_verifier
    AS-->>C: access_token + refresh_token
```

**1. Bind a temporary callback server**

Pick a random high port and bind it to `127.0.0.1` or `[::1]`, never
`0.0.0.0`.

**2. Generate PKCE and state**

`code_verifier`, `code_challenge`, and `state`. See
[above](#generating-pkce-values-and-state).

**3. Get a client\_id**

Use the URL of a [metadata document](#client-id-metadata-documents) that
lists the loopback redirect URI and the minimum required scope. If the
client can't host one, register dynamically with the same values instead.
See [Register Client](/docs/api-reference/oauth/register).

**4. Open the authorize URL in the user's browser**

Don't prefetch `/oauth/authorize` from your process and follow the redirect
yourself. The user needs to see the consent screen.

**5. Let the browser follow the redirect to the dashboard consent screen**

**6. Handle exactly one callback, then close the server**

**7. Reject invalid callbacks**

A missing `code`, mismatched or missing `state`, or an `error` query
parameter should all be treated as failures.

**8. Exchange the code**

Use the original `code_verifier`. See [Token](/docs/api-reference/oauth/token).

**9. Store the newest refresh token after every token response**

Close the loopback server after success or timeout.

### Dynamic client registration

Pass `scope` explicitly. If DCR omits `scope`, Resend registers the client with both scopes by default.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/register' \
     -H 'Content-Type: application/json' \
     -d $'{
  "client_name": "Example Local OAuth Client",
  "redirect_uris": ["http://127.0.0.1/oauth/callback"],
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"],
  "token_endpoint_auth_method": "none",
  "scope": "emails:send"
}'
```

The response returns a UUID `client_id`:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "client_id": "550e8400-e29b-41d4-a716-446655440000",
  "client_id_issued_at": 1750000000,
  "client_name": "Example Local OAuth Client",
  "redirect_uris": ["http://127.0.0.1/oauth/callback"],
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"],
  "token_endpoint_auth_method": "none",
  "scope": "emails:send"
}
```

### Authorization request

Do not have a backend or CLI process prefetch `/oauth/authorize` and then open the returned dashboard URL. Instead, open the authorization URL in the user's browser and let the browser follow the redirect to the dashboard.

```javascript theme={"theme":{"light":"github-light","dark":"vesper"}}
const authorizationUrl = new URL('https://api.resend.com/oauth/authorize');
authorizationUrl.search = new URLSearchParams({
  client_id: '550e8400-e29b-41d4-a716-446655440000',
  response_type: 'code',
  redirect_uri: 'http://127.0.0.1:49152/oauth/callback',
  scope: 'emails:send',
  state,
  code_challenge: codeChallenge,
  code_challenge_method: 'S256',
}).toString();

openBrowser(authorizationUrl.toString());
```

After approval, Resend redirects back to the exact `redirect_uri` used in the authorization request:

```
GET /oauth/callback?code=AUTHORIZATION_CODE&state=STATE_VALUE HTTP/1.1
Host: 127.0.0.1:49152
```

Verify that the returned `state` matches the original `state` before exchanging the code.

### Authorization code exchange

The `redirect_uri` in the token request must match the `redirect_uri` from the authorization request.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/token' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'grant_type=authorization_code&client_id=550e8400-e29b-41d4-a716-446655440000&code=AUTHORIZATION_CODE&redirect_uri=http%3A%2F%2F127.0.0.1%3A49152%2Foauth%2Fcallback&code_verifier=CODE_VERIFIER_VALUE'
```

The response includes a JWT access token and an opaque refresh token:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "access_token": "eyJhbGciOiJFUzI1NiIsImtpZCI6Im9hdXRoX2tleSIsInR5cCI6ImF0K2p3dCJ9...",
  "token_type": "Bearer",
  "expires_in": 900,
  "refresh_token": "JcL7aYfE7S9h3L4qv0o2e1w8m6n5b3x9RkP2tD4uV6Q",
  "scope": "emails:send"
}
```

### Refresh token exchange

Refresh tokens rotate on every successful refresh. Serialize refresh operations for a grant, and store the new refresh token atomically with the rest of the response. If refresh succeeds but the new refresh token isn't persisted, you'll need to reauthorize. Retrying an old token from multiple workers can revoke the whole grant: a replay fails with `invalid_grant` either way, and it also revokes the grant unless the rotation happened within the last minute. Don't rely on that window. See [Token](/docs/api-reference/oauth/token) for the reuse-detection details.

Each refresh resets the new token's 60-day lifetime, so a client that refreshes regularly never has to reauthorize.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/token' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'grant_type=refresh_token&client_id=550e8400-e29b-41d4-a716-446655440000&refresh_token=JcL7aYfE7S9h3L4qv0o2e1w8m6n5b3x9RkP2tD4uV6Q'
```

## Revoking access

To disconnect a client, revoke the refresh token:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/oauth/revoke' \
     -H 'Content-Type: application/x-www-form-urlencoded' \
     -d 'client_id=550e8400-e29b-41d4-a716-446655440000&token=JcL7aYfE7S9h3L4qv0o2e1w8m6n5b3x9RkP2tD4uV6Q&token_type_hint=refresh_token'
```

A confidential client must authenticate this request too, the same way it does at the token endpoint. For example, pass its `client_secret` with `curl -u 'CLIENT_ID:CLIENT_SECRET'` instead of sending `client_id` in the body.

Access tokens are JWTs and can't be revoked individually. Revoking the refresh token revokes the grant. See [Revoke Token](/docs/api-reference/oauth/revoke).


# Send emails with Devin and Resend
Source: https://resend.com/docs/guides/devin

Learn how to install the Resend MCP server in Devin.ai so your agent can send emails, manage contacts, and run broadcasts.

[Devin](https://devin.ai) is an autonomous AI software engineer that can connect to external services through MCP (Model Context Protocol) servers. Adding Resend's MCP server gives Devin native access to send emails, manage contacts and broadcasts, verify domains, and more.

For the full list of capabilities, see the [MCP Server overview](/docs/mcp-server).

## Prerequisites

Before you start, make sure you have:

* A Devin account with access to the Settings menu
* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Open Devin Settings**

In Devin, open the **Settings** menu from your account dropdown.

**2. Go to Connections > MCP Servers**

In the Settings sidebar, click **Connections**, then select the **MCP Servers** tab. Click **Add a custom MCP**.

![Selecting MCP Servers under Connections in Devin](https://mintcdn.com/resend/YZqtGqf82akku4IQ/images/devin-connections-mcp.png?fit=max\&auto=format\&n=YZqtGqf82akku4IQ\&q=85\&s=1e0d35803e6121917d042a84f9459cd0)

**3. Add the Resend MCP configuration**

Click **Import JSON** and paste the following configuration into the modal.

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "mcpServers": {
    "resend": {
      "command": "npx",
      "args": ["-y", "resend-mcp"],
      "env": {
        "RESEND_API_KEY": "re_xxxxxxxxx",
        "SENDER_EMAIL_ADDRESS": "onboarding@resend.dev"
      }
    }
  }
}
```

![Pasting the Resend MCP configuration in Devin](https://mintcdn.com/resend/YZqtGqf82akku4IQ/images/devin-mcp-config.png?fit=max\&auto=format\&n=YZqtGqf82akku4IQ\&q=85\&s=37b3b24c60d34f932db1dc7d7cdae104)

**4. Update the Environment Variables**

Scroll down and update the environment variables:

* `RESEND_API_KEY`: delete this and add it as a secret (see the next step).
* `SENDER_EMAIL_ADDRESS`: update this with your sender email address you've verified in the [Resend Dashboard](https://resend.com/domains).

  ![Update the environment variables](https://mintcdn.com/resend/YZqtGqf82akku4IQ/images/devin-update-env.png?fit=max\&auto=format\&n=YZqtGqf82akku4IQ\&q=85\&s=2e99d816ea35a7c58846fc0f0ea3cf87)

**5. Add the Resend API key as a secret**

Add the `RESEND_API_KEY` as a secret. Click **Save secret** to confirm.

![Adding the Resend API key as a Devin secret](https://mintcdn.com/resend/YZqtGqf82akku4IQ/images/devin-add-secret.png?fit=max\&auto=format\&n=YZqtGqf82akku4IQ\&q=85\&s=d10ab3297311c5cc67b2bf18d91c3409)

> [!NOTE]
>
> You can create a new API key in the [Resend
> Dashboard](https://resend.com/api-keys).

**6. Confirm and enable the MCP server**

Add a description, click **Install and Enable**, and confirm in the dialog. Devin will install the server and mark it as connected.

![Confirming the Resend MCP server in Devin](https://mintcdn.com/resend/YZqtGqf82akku4IQ/images/devin-confirm-mcp.png?fit=max\&auto=format\&n=YZqtGqf82akku4IQ\&q=85\&s=3cb215a070a170cdda1d967c5d7b10e1)

**7. Test the connection**

Ask Devin to send a test email. For example:

```text theme={"theme":{"light":"github-light","dark":"vesper"}}
Send a test email to delivered@resend.dev using the Resend MCP server. Subject: "Hello from Devin".
```

Devin will call the Resend MCP server and confirm the send.


# Cloudflare
Source: https://resend.com/docs/guides/dns/cloudflare

Verify your domain on Cloudflare with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Automatic Setup (Recommended)

The fastest way to verify your domain on Cloudflare is using the **Sign in to Cloudflare** button on Resend. This uses Domain Connect to automatically configure your DNS records.

1. Go to your [Domains page](https://resend.com/domains) in Resend.
2. (Optional) If you want to receive emails, select `Manual setup` and toggle the "Receiving" switch on the domain details page. ([Learn more below](#receiving-emails))
3. Click **Sign in to Cloudflare** button.
4. Authorize Resend to access your Cloudflare DNS settings.
5. The DNS records will be added automatically.

<video aria-label="Cloudflare Domain Connect Setup" />

That's it. Your domain will be verified within a few minutes.

## Manual Setup

If you prefer to add DNS records manually, follow these steps.

### Log in to Cloudflare

Log in to your [Cloudflare account](https://cloudflare.com) and go to the DNS Records of your domain.

![Domain Details](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-domains-cloudflare-main.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=ffd61997133f0af6f4ba8d14df82dcdc)

### Add MX SPF Record

Click "Add Record" on Cloudflare:

1. Set the Type to `MX`.
2. Type `send` for the `Name` of the record.
3. Copy the MX Value from Resend into the `Mail Server` field.
4. Use the default `Auto` for `TTL`.
5. Add `10` for the `Priority`.
6. Select `Save`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-domains-cloudflare-spf-mx.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=372024c515c4b6924e5a1314ad831b6f)

Below is a mapping of the record fields from Resend to Cloudflare:

| Cloudflare | Resend | Example Value |
| - | - | - |
| Type | Type | `MX` |
| Name | Name | `send` |
| Mail Server | Content | `feedback-smtp.us-east-1.amazonses.com` |
| Priority | Priority | `10` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

> [!NOTE]
>
> Do not use the same priority for multiple records. If Priority `10` is already
> in use, try a higher value `20` or `30`.

### Add TXT SPF Record

Click "Add Record" on Cloudflare:

1. Set the Type to `TXT`.
2. Type `send` for the `Name` of the record.
3. Copy the TXT Value Resend into `Content` field.
4. Use the default `Auto` for `TTL`.
5. Select `Save`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-domains-cloudflare-spf-txt.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=3a20409e0c792c602f4eb636dcfbc3ac)

Below is a mapping of the record fields from Resend to Cloudflare:

| Cloudflare | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT` |
| Name | Name | `send` |
| Content | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL | - | `Auto` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

### Add TXT DKIM Records

Click "Add Record" on Cloudflare:

1. Set the Type to `TXT`.
2. Type `resend._domainkey` for the `Name` of the record.
3. Copy the TXT Value Resend into `Content` field.
4. Use the default `Auto` for `TTL`.
5. Select `Save`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-domains-cloudflare-dkim-txt.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=dafb2d6d5050da130371a2b7a8390abd)

Below is a mapping of the record fields from Resend to Cloudflare:

| Cloudflare | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT` |
| Name | Name | `resend._domainkey` |
| Target | Content | `p=example_domain_key_value` |
| Proxy Status | - | `DNS Only (disabled)` |
| TTL | - | `Auto` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

### Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Click “Add Record” on Cloudflare:

1. Set the Type to `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
3. Copy the MX Value from Resend into the `Mail Server` field.
4. Use the default `Auto` for `TTL`.
5. Add `10` for the `Priority`.
6. Select `Save`.

Below is a mapping of the record fields from Resend to Cloudflare:

| Cloudflare | Resend | Example Value |
| - | - | - |
| Type | Type | `MX` |
| Name | Name | `inbound` |
| Mail Server | Content | `inbound-smtp.us-east-1.amazonaws.com` |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

### Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take up to 72 hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Cloudflare returns 'Code: 1004' when adding CNAME Records.
>
> Confirm your proxy settings are set to `DNS Only` on the record you are adding.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Cloudflare to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# DreamHost
Source: https://resend.com/docs/guides/dns/dreamhost

Verify your domain on DreamHost with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to DreamHost

1. Log in to your [DreamHost panel](https://panel.dreamhost.com).

2. Go to **Websites > Manage Websites**.

3. Select **Manage** on the domain you want to verify.

   ![DreamHost DNS TXT Record](https://mintcdn.com/resend/7M2Hdgv3dPiLlTrA/images/dashboard-domains-dreamhost-website.png?fit=max\&auto=format\&n=7M2Hdgv3dPiLlTrA\&q=85\&s=006357ac32d5cd380fdb83b995149e09)

## Add TXT SPF Record

1. Navigate to the **DNS** tab.
2. Enter `send` as Host.
3. Enter `v=spf1 include:amazonses.com ~all` as TXT Value.
4. Click **Add Record**.

Below is a mapping of the record fields from Resend to DreamHost:

| DreamHost | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Host | Name | `send` |
| TXT Value | Content | `v=spf1 include:amazonses.com ~all` |

![DreamHost DNS Dashboard](https://mintcdn.com/resend/7M2Hdgv3dPiLlTrA/images/dashboard-domains-dreamhost-spf.png?fit=max\&auto=format\&n=7M2Hdgv3dPiLlTrA\&q=85\&s=8c285c277231e0f0abbe68b8cdf67e66)

## Add TXT DKIM Records

1. In the same window, add another TXT record.

2. Add `resend._domainkey` as Host.

3. Copy the value from your domain configuration page in Resend and paste it into DreamHost.

   ![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

4. Click **Add Record**.

   ![DreamHost DNS Dashboard](https://mintcdn.com/resend/7M2Hdgv3dPiLlTrA/images/dashboard-domains-dreamhost-dkim.png?fit=max\&auto=format\&n=7M2Hdgv3dPiLlTrA\&q=85\&s=90f2e23d3b70ff95c418e178489df7bb)

   Below is a mapping of the record fields from Resend to DreamHost:

| DreamHost | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Host | Name | `resend._domainkey` |
| TXT Value | Content | `p=example_domain_key_value` |

## Add MX SPF Record

1. Create a subdomain with the custom path name. Return to **Manage Websites** page. Click **Add Website**.

   ![DreamHost Website](https://mintcdn.com/resend/7M2Hdgv3dPiLlTrA/images/dashboard-domains-dreamhost-subdomain.png?fit=max\&auto=format\&n=7M2Hdgv3dPiLlTrA\&q=85\&s=7964ed472542c62a5aae1459e4a19bdb)
2. Click **Manage** on the subdomain.
3. **Add Record** > Select **MX** > **Manage Customer MX**.
4. Copy and paste the MX value replacing the default record.

   ![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![DreamHost Website](https://mintcdn.com/resend/7M2Hdgv3dPiLlTrA/images/dashboard-domains-dreamhost-custom-mx.png?fit=max\&auto=format\&n=7M2Hdgv3dPiLlTrA\&q=85\&s=0f0aae42669dd7024fef53137458f5f4)

Below is a mapping of the record fields from Resend to DreamHost:

| DreamHost | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Host | Name | `send` |
| Points to | Content | `feedback-smtp.us-east-1.amazonses.com` |
| Priority | Priority | `10` |

> [!NOTE]
>
> MX record will differ depending on your selected sending region.

> [!NOTE]
>
> Do not use the same priority for multiple MX records. If Priority `10` is
> already in use, try a higher value such as `20` or `30`.

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Add an MX record for receiving:

1. Click the **Add Record** button.
2. Hover over the **MX Record** section and click **ADD**.
3. Enter `inbound` (or your receiving subdomain) in the **Host** field.
4. Copy the MX Value from Resend into the **Points to** field.
5. Enter `10` for **Priority**.
6. Click **Add Record** to save.

Below is a mapping of the record fields from Resend to DreamHost:

| DreamHost | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Host | Name | `inbound` |
| Points to | Content | `inbound-smtp.us-east-1.amazonaws.com` |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take up to 72 hours to complete the verification process (often much faster). DNS updates at DreamHost can take several hours to propagate.

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to DreamHost to rule out copy and paste errors.
> Ensure the **Host** field uses only the subdomain (e.g., `send` or
> `resend._domainkey`) and that you did not include the full domain name.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# Gandi
Source: https://resend.com/docs/guides/dns/gandi

Verify your domain on Gandi with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to Gandi

Log in to your [Gandi account](https://admin.gandi.net/domain/):

1. Choose your Domain from the `Domain` list.
2. Select the `DNS Records` tab to get to the page to manage DNS records.

![Domain Details](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-domains-gandi-domains.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=db72a28a42a006e10ca7617fc004ecb5)

## Add MX SPF Record

Select “Add record” on Gandi to copy and paste the values MX from Resend.

1. On the `Type` page, choose `MX`.
2. Use the default TTL of `10800`.
3. Type `send` for the `Name` of the record.
4. Use the default `Priority` of `10`.
5. Copy the MX Value from Resend into the `Hostname` field.
6. Select `Create`.

> [!NOTE]
>
> Gandi requires your MX record to have a trailing period when adding. Resend
> will include the trailing period when copying. Removing the period will cause
> the verification to fail.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-gandi-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=41f5e1b53f159b7e8e05f4f1ffa7e5ad)

Below is a mapping of the record fields from Resend to Gandi:

| Gandi | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `send` |
| Hostname | Content | `feedback-smtp.us-east-1.amazonses.com.` |
| TTL | - | `10800` |
| Priority | Priority | `10` |

> [!NOTE]
>
> Do not use the same priority for multiple records. If Priority `10` is already
> in use on another record, try a higher value `20` or `30`.

## Add TXT SPF Record

In the same section, select “Add record” again.

1. On the `Type` page, choose `TXT`.
2. Use the default TTL of `10800`.
3. Type `send` for the `Name` of the record.
4. Copy the TXT Value Resend into the `Text value` field.
5. Select `Create`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-gandi-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=7f75828142bfae8186b3f577d379c910)

Below is a mapping of the record fields from Resend to Gandi:

| Gandi | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send` |
| Text value | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL | - | `10800` |

## Add TXT DKIM Records

In the same section, select “Add record” again.

1. On the `Type` page, choose `TXT`.
2. Use the default TTL of `10800`.
3. Type `resend._domainkey` for the `Host name` of the record.
4. Copy the record value from Resend into the `TXT value` field.
5. Select `Create`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/dashboard-domains-gandi-dkim-txt.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=097889c1a13da8b1634cddadfe294887)

Below is a mapping of the record fields from Resend to Gandi:

| Gandi | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send` |
| Text value | Content | `p=example_domain_key_value` |
| TTL | - | `1 hour` |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Select “Add record” on Gandi:

1. On the `Type` page, choose `MX`.
2. Use the default TTL of `10800`.
3. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
4. Use the default `Priority` of `10`.
5. Copy the MX Value from Resend into the `Hostname` field.
6. Select `Create`.

Below is a mapping of the record fields from Resend to Gandi:

| Gandi | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `inbound` |
| Hostname | Content | `inbound-smtp.us-east-1.amazonaws.com.` |
| TTL | - | `10800` |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Gandi to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# GoDaddy
Source: https://resend.com/docs/guides/dns/godaddy

Verify your domain on GoDaddy with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Automatic Setup (Recommended)

The fastest way to verify your domain on GoDaddy is using the **Auto Configure** button on Resend. This uses Domain Connect to automatically configure your DNS records.

1. Go to your [Domains page](https://resend.com/domains) in Resend.
2. (Optional) If you want to receive emails, select `Manual setup` and toggle the "Receiving" switch on the domain details page. ([Learn more below](#receiving-emails))
3. Click **Auto Configure**.
4. Authorize Resend to access your GoDaddy DNS settings.
5. The DNS records will be added automatically.

<video aria-label="GoDaddy Domain Connect Setup" />

That's it. Your domain will be verified within a few minutes.

## Manual Setup

If you prefer to add DNS records manually, follow these steps.

### Log in to GoDaddy

Log in to your [GoDaddy account](https://sso.godaddy.com):

1. Select `DNS` from the left navigation
2. Find your domain in the list and select the domain
3. This will take you to the DNS management page for the domain

![Domain Details](https://mintcdn.com/resend/lQ2IedTbqKrTHWy8/images/dashboard-domains-godaddy-manage.png?fit=max\&auto=format\&n=lQ2IedTbqKrTHWy8\&q=85\&s=544f608675414a8e562ee15665a9b102)

## Add MX SPF Record

Copy and paste the values MX in Resend to GoDaddy.

1. Click `Add New Record` to create a new record
2. Set the Type to `MX`.
3. Type `send` for the `Name` of the record.
4. Copy the MX Value from Resend into the `Value` field.
5. Add `10` for the `Priority`.
6. Set the TTL to `600` (or use the default).
7. Click `Save`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/lQ2IedTbqKrTHWy8/images/dashboard-domains-godaddy-spf-mx.png?fit=max\&auto=format\&n=lQ2IedTbqKrTHWy8\&q=85\&s=22442a78539dc70a959a152a396e8508)

Below is a mapping of the record fields from Resend to GoDaddy:

| GoDaddy | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `send` |
| Value | Content | `feedback-smtp.us-east-1.amazonses.com` |
| TTL | - | `600` (or use default) |
| Priority | Priority | `10` |

> [!NOTE]
>
> Do not use the same priority for multiple records. If Priority `10` is already
> in use on another record, try a higher value `20` or `30`.

## Add TXT SPF Record

In the same section, add another record in GoDaddy.

1. Click `Add New Record` to create a new record
2. Set the Type to `TXT`.
3. Type `send` for the `Name` of the record.
4. Copy the TXT Value from Resend into the `Value` field.
5. Set the TTL to `600` (or use the default).
6. Click `Save`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/lQ2IedTbqKrTHWy8/images/dashboard-domains-godaddy-spf-txt.png?fit=max\&auto=format\&n=lQ2IedTbqKrTHWy8\&q=85\&s=849bd76a0e5c14daa2f727ed2f284036)

Below is a mapping of the record fields from Resend to GoDaddy:

| GoDaddy | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send` |
| Value | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL | - | `600` (or use default) |

## Add TXT DKIM Records

In the same section, add another record in GoDaddy.

1. Click `Add New Record` to create a new record
2. Set the Type to `TXT`.
3. Type `resend._domainkey` for the `Name` of the record.
4. Copy the record value from Resend into the `Value` field.
5. Set the TTL to `600` (or use the default).
6. Click `Save`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/lQ2IedTbqKrTHWy8/images/dashboard-domains-godaddy-dkim-txt.png?fit=max\&auto=format\&n=lQ2IedTbqKrTHWy8\&q=85\&s=2df8ab88c72f0944f8071121e95295aa)

Below is a mapping of the record fields from Resend to GoDaddy:

| GoDaddy | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `resend._domainkey` |
| Value | Content | `p=example_domain_key_value` |
| TTL | - | `600` (or use default) |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Click `Add New Record` to create a new record:

1. Set the Type to `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
3. Copy the MX Value from Resend into the `Value` field.
4. Add `10` for the `Priority`.
5. Set the TTL to `600` (or use the default).
6. Click `Save`.

Below is a mapping of the record fields from Resend to GoDaddy:

| GoDaddy | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `inbound` |
| Value | Content | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL | - | `600` (or use default) |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to GoDaddy to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# Hetzner
Source: https://resend.com/docs/guides/dns/hetzner

Verify your domain on Hetzner with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to Hetzner Console

This section covers accessing the new Hetzner Console for managing DNS records. If your domain is still using the legacy Hetzner DNS console, please skip to the [Log in to Hetzner DNS Console](#log-in-to-hetzner-dns-console) section below.

Log in to [Hetzner Console](https://console.hetzner.com/):

1. Choose your project from the `Projects` list.
2. Click on the `DNS` link from the `Networking` section of the side navigation.
3. Choose your Domain from the `DNS zones` list.

![Domain Details](https://mintcdn.com/resend/JnEHZ2RkJvy-KeG2/images/dashboard-domains-Hetzner-console-dns.png?fit=max\&auto=format\&n=JnEHZ2RkJvy-KeG2\&q=85\&s=b8f96a05c8b1115639ba85ce616716ec)

## Log in to Hetzner DNS Console

This section covers accessing the legacy Hetzner DNS Console. Hetzner recently created the new Hetzner Console for managing DNS records. If your domain is using the new Hetzner console, please go to the [Log in to Hetzner Console](#log-in-to-hetzner-console) section above then skip to the [Add MX SPF Record](#add-mx-spf-record) section.

Log in to [Hetzner DNS Console](https://dns.hetzner.com):

1. Choose your Domain from the `Your Zones` list.
2. Select the `Records` tab to get to the page to manage DNS records.

![Domain Details](https://mintcdn.com/resend/JnEHZ2RkJvy-KeG2/images/dashboard-domains-Hetzner-dns-console-domains.png?fit=max\&auto=format\&n=JnEHZ2RkJvy-KeG2\&q=85\&s=491d0aab1c3722d47159c8e42fe880ba)

## Add MX SPF Record

In the `Add Record` section on Hetzner copy and paste the values MX from Resend:

1. For the `Type` field, choose `MX`.
2. For the `Name` field, type `send` (or `send.subdomain` if you're using a subdomain).
3. For the `Priority` field, set the value to `10`.
4. For the `Value` field, add the MX SPF Record `Content` from Resend.
5. For the `TTL` field, set the value to `1800`.
6. Select `Add`.

> [!NOTE]
>
> Hetzner requires your MX record to have a trailing period when adding. Resend
> will include the trailing period when copying. Removing the period will cause
> the verification to fail.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/JnEHZ2RkJvy-KeG2/images/dashboard-domains-Hetzner-console-spf-mx.png?fit=max\&auto=format\&n=JnEHZ2RkJvy-KeG2\&q=85\&s=29ce3bf6e50439348e0d3bf2f90110de)

Below is a mapping of the record fields from Resend to Hetzner Console:

| Hetzner | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `send.subdomain` |
| Value | Content | `feedback-smtp.us-east-1.amazonses.com.` |
| TTL | TTL | `1800` |
| Priority | Priority | `10` |

> [!NOTE]
>
> Do not use the same priority for multiple records. If Priority `10` is already
> in use on another record, try a higher value `20` or `30`.

## Add TXT SPF Record

On the same `Add Record` section:

1. For the `Type` field, choose `TXT`.
2. For the `Name` field, type `send` (or `send.subdomain` if you're using a subdomain).
3. For the `Value` field, add the TXT SPF Record `Content` from Resend.
4. For the `TTL` field, set the value to `1800`.
5. Select `Add`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/JnEHZ2RkJvy-KeG2/images/dashboard-domains-Hetzner-console-spf-txt.png?fit=max\&auto=format\&n=JnEHZ2RkJvy-KeG2\&q=85\&s=9cfd4af1fd47c8bf7f0e80bd2c846497)

Below is a mapping of the record fields from Resend to Hetzner:

| Hetzner | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send.subdomain` |
| Value | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL | TTL | `10800` |

## Add TXT DKIM Records

On the same `Add Record` section:

1. For the `Type` field, choose `TXT`.
2. For the `Name` field, type `resend._domainkey` (or `resend._domainkey.subdomain` if you're using a subdomain).
3. For the `Value` field, add the TXT DKIM Record `Content` from Resend.
4. For the `TTL` field, set the value to `1800`.
5. Select `Add`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/JnEHZ2RkJvy-KeG2/images/dashboard-domains-Hetzner-console-dkim-txt.png?fit=max\&auto=format\&n=JnEHZ2RkJvy-KeG2\&q=85\&s=96d275fc831f3bfde0aec1c9b5325385)

Below is a mapping of the record fields from Resend to Hetzner:

| Hetzner | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send.subdomain` |
| Value | Content | `p=example_domain_key_value` |
| TTL | TTL | `1 hour` |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

![Domain Details](https://mintcdn.com/resend/JnEHZ2RkJvy-KeG2/images/dashboard-domains-Hetzner-console-inbound-mx.png?fit=max\&auto=format\&n=JnEHZ2RkJvy-KeG2\&q=85\&s=b292bfefc0c463ebe78e0f77fb283263)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

In the `Add Record` section on Hetzner:

1. For the `Type` field, choose `MX`.
2. For the `Name` field, type `@` for the base domain or the name of the subdomain if you're using a subdomain.
3. For the `Priority` field, set the value to `10`.
4. For the `Value` field, add the Receiving MX Record `Content` from Resend.
5. For the `TTL` field, set the value to `1800`.
6. Select `Add`.

Below is a mapping of the record fields from Resend to Hetzner:

| Hetzner | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `subdomain` |
| Mail server | Content | `inbound-smtp.us-east-1.amazonaws.com.` |
| TTL | TTL | `1800` |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Hetzner to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# Hostinger
Source: https://resend.com/docs/guides/dns/hostinger

Verify your domain on Hostinger with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to Hostinger

Log in to your [Hostinger account](https://auth.hostinger.com/login):

1. Select the `Domains` tab
2. Choose your Domain from the `Domain portfolio` list.
3. Select the `DNS / Nameservers` to get to the page to manage DNS records.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-hostinger-domains.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=d7fcfa6f62bc4c8eb8c7eccbc12068c3)

## Add MX SPF Record

Copy and paste the values MX in Resend to Hostinger.

1. Set the Type to `MX`.
2. Type `send` for the `Name` of the record.
3. Copy the MX Value from Resend into the `Mail Server` field.
4. Add `10` for the `Priority`.
5. Set the TTL to `3600`.
6. Select `Add Record`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-hostinger-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=d9600d2ba927c8ee8a3222139280d396)

Below is a mapping of the record fields from Resend to Hostinger:

| Hostinger | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `send` |
| Mail Server | Content | `feedback-smtp.us-east-1.amazonses.com` |
| TTL | - | `Set to 3660` |
| Priority | Priority | `10` |

> [!NOTE]
>
> Do not use the same priority for multiple records. If Priority `10` is already
> in use on another record, try a higher value `20` or `30`.

## Add TXT SPF Record

In the same section, add another record in Hostinger.

1. Set the Type to `TXT`.
2. Type `send` for the `Name` of the record.
3. Copy the TXT Value Resend into the `TXT value` field.
4. Set the TTL to `3600`.
5. Select `Add Record`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-hostinger-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=8854129a0f11574f79016d5ad56a0ed2)

Below is a mapping of the record fields from Resend to Hostinger:

| Hostinger | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send` |
| TXT value | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL | - | `Set to 3600` |

## Add TXT DKIM Records

In the same section, add another record in Hostinger.

1. Set the Type to `TXT`.
2. Type `resend._domainkey` for the `Name` of the record.
3. Copy the record value from Resend into the `TXT value` field.
4. Set the TTL to `3600`.
5. Select `Add Record`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-hostinger-dkim-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=31350bb523d1959c348a0fde5f8d5734)

Below is a mapping of the record fields from Resend to Hostinger:

| Hostinger | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send` |
| TXT value | Content | `p=example_domain_key_value` |
| TTL | - | `Set to 3600` |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Copy and paste the values MX in Resend to Hostinger:

1. Set the Type to `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
3. Copy the MX Value from Resend into the `Mail Server` field.
4. Add `10` for the `Priority`.
5. Set the TTL to `3600`.
6. Select `Add Record`.

Below is a mapping of the record fields from Resend to Hostinger:

| Hostinger | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `inbound` |
| Mail Server | Content | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL | - | `Set to 3660` |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Hostinger to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# IONOS
Source: https://resend.com/docs/guides/dns/ionos

Verify your domain on IONOS with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to IONOS

Log in to your [IONOS account](https://my.ionos.com/domains):

1. Choose your Domain from the `Domain` list.
2. Select the `DNS` tab to get to the page to manage DNS records.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-ionos-domains.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=ad87e97d0b64b83ef7076abdcca7f032)

## Add MX SPF Record

Select “Add record” on IONOS to copy and paste the values MX from Resend.

1. On the `Add a DNS Record` page, select `MX`.
2. Type `send` for the `Name` of the record.
3. Copy the MX Value from Resend into the `Points to` field.
4. Use the default `Priority` of `10`.
5. Use the default TTL of `1 hour`.
6. Select `Save`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-ionos-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=1769321e813bf9a6d6ebe30105d1dc43)

Below is a mapping of the record fields from Resend to IONOS:

| IONOS | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `send` |
| Points to | Content | `feedback-smtp.us-east-1.amazonses.com` |
| TTL | TTL | `1 hour` |
| Priority | Priority | `10` |

> [!NOTE]
>
> Do not use the same priority for multiple records. If Priority `10` is already
> in use on another record, try a higher value `20` or `30`.

## Add TXT SPF Record

In the same section, select “Add record” again.

1. On the `Add a DNS Record` page, select `TXT`.
2. Type `send` for the `Host name` of the record.
3. Copy the TXT Value Resend into the `TXT value` field.
4. Use the default TTL of `1 hour`.
5. Select `Save`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-ionos-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=b41183957e0b51879bf42e16f1927f91)

Below is a mapping of the record fields from Resend to IONOS:

| IONOS | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Host name | Name | `send` |
| TXT value | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL | - | `1 hour` |

## Add TXT DKIM Records

In the same section, select “Add record” again.

1. On the `Add a DNS Record` page, select `TXT`.
2. Type `resend._domainkey` for the `Host name` of the record.
3. Copy the record value from Resend into the `TXT value` field.
4. Use the default TTL of `1 hour`.
5. Select `Save`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-ionos-dkim-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=f824ef363e11048dd685cf8afad2cf53)

Below is a mapping of the record fields from Resend to IONOS:

| IONOS | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Host name | Name | `send` |
| TXT value | Content | `p=example_domain_key_value` |
| TTL | - | `1 hour` |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Select “Add record” on IONOS:

1. On the `Add a DNS Record` page, select `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
3. Copy the MX Value from Resend into the `Points to` field.
4. Use the default `Priority` of `10`.
5. Use the default TTL of `1 hour`.
6. Select `Save`.

Below is a mapping of the record fields from Resend to IONOS:

| IONOS | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `inbound` |
| Points to | Content | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL | TTL | `1 hour` |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to IONOS to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# Namecheap
Source: https://resend.com/docs/guides/dns/namecheap

Verify your domain on Namecheap with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to Namecheap

1. Log in to your [Namecheap account](https://ap.www.namecheap.com).

2. Click `Manage` for the domain.

   ![Domain Details](https://mintcdn.com/resend/svdlrksWLy8Dr3X-/images/dashboard-domains-namecheap-manage.png?fit=max\&auto=format\&n=svdlrksWLy8Dr3X-\&q=85\&s=cb8698fd0e0cab38eb335766a9d0b7d8)

   > [!NOTE]
   >
   > You may need to expand a dropdown to see the `Manage` button.

3. Go to the `Advanced DNS` page for the domain you want to verify.

   ![Domain Details](https://mintcdn.com/resend/svdlrksWLy8Dr3X-/images/dashboard-domains-namecheap-advanced-dns.png?fit=max\&auto=format\&n=svdlrksWLy8Dr3X-\&q=85\&s=b958e136050178c70eb4820e703803c6)

## Add MX SPF Record

> [!WARNING]
>
> If you are changing the MX configuration from `Gmail` to `Custom MX`, you need
> to [setup new MX records for
> Gmail](https://support.google.com/a/answer/174125). If you don't setup new
> records, receiving mail in your gmail inboxes will stop.

Under the `Mail Settings` section, click the dropdown and select `Custom MX`:

1. Type `send` for the `Host` of the record.
2. Copy the MX Value from Resend into the `Value` field.
3. Use the `Automatic` TTL.
4. Select `Save all changes`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-namecheap-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=dda5ff041cce1341e22123fd70111ef3)

Below is a mapping of the record fields from Resend to Namecheap:

| Namecheap | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Host | Name | `send` |
| TTL | TTL | `Automatic` |
| Value | Content | `feedback-smtp.us-east-1.amazonses.com` |
| - | Priority | `10` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

> [!NOTE]
>
> Namecheap does not label the `priority` column. It is the empty column after
> `Value`. Do not use the same priority for multiple records. If Priority `10`
> is already in use, try a higher value `20` or `30`.

## Add TXT SPF Record

Under the `Host Records` section, click `Add New Record`:

1. Set the `Type` to `TXT Record`.
2. Enter `send` into the `Host` field.
3. Copy the TXT Value from Resend into the `Value` field.
4. Use the `Automatic` TTL.
5. Select `Save all changes`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-namecheap-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=b742409a1de5a3291dc64e1846c2cf77)

Below is a mapping of the record fields from Resend to Namecheap:

| Namecheap | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Host | Name | `send` |
| TTL | TTL | `Automatic` |
| Value | Content | `"v=spf1 include:amazonses.com ~all"` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

## Add TXT DKIM Records

In that same `Host Records` section, click `Add New Record`.

1. Set the `Type` to `TXT Record`.
2. Enter `resend._domainkey` into the `Host` field.
3. Copy the TXT Value from Resend into the `Value` field.
4. Use the `Automatic` TTL.
5. Select `Save all changes`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-namecheap-dkim-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=0cd6480b613eaed711006b58c7b7a67a)

Below is a mapping of the record fields from Resend to Namecheap:

| Namecheap | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Host | Name | `resend._domainkey` |
| TTL | TTL | `Automatic` |
| Value | Content | `p=example_domain_key_value` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Under the `Mail Settings` section, click the dropdown and select `Custom MX`:

1. Type `inbound` (or whatever your subdomain is) for the `Host` of the record.
2. Copy the MX Value from Resend into the `Value` field.
3. Use the `Automatic` TTL.
4. Select `Save all changes`.

Below is a mapping of the record fields from Resend to Namecheap:

| Namecheap | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Host | Name | `inbound` |
| TTL | TTL | `Automatic` |
| Value | Content | `inbound-smtp.us-east-1.amazonaws.com` |
| - | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take up to 72 hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Namecheap to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# Porkbun
Source: https://resend.com/docs/guides/dns/porkbun

Verify your domain on Porkbun with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to Porkbun

Log in to your [Porkbun account](https://porkbun.com/account/domainsSpeedy):

1. Select the `DNS` option under your domain to manage DNS records.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-porkbun-domains.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=44389c4ae53707e508d38a34a794cec3)

## Add MX SPF Record

In the `DNS` section on Porkbun copy and paste the values MX from Resend:

1. On the `Type` page, choose `MX`.
2. Type `send` for the `Host` of the record.
3. Copy the MX Value from Resend into the `Answer / Value` field.
4. Use the default TTL of `600`.
5. In the `Priority` field enter `10`.
6. Select `Add`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-porkbun-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=65428888fca00600f2bdf31d14db8eaf)

Below is a mapping of the record fields from Resend to Porkbun:

| Porkbun | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Host | Name | `send` |
| Answer / Value | Content | `feedback-smtp.us-east-1.amazonses.com` |
| TTL | TTL | `600` |
| Priority | Priority | `10` |

> [!NOTE]
>
> Do not use the same priority for multiple records. If Priority `10` is already
> in use on another record, try a higher value `20` or `30`.

## Add TXT SPF Record

On the same section:

1. On the `Type` page, choose `TXT`.
2. Type `send` for the `Host` of the record.
3. Copy the TXT Value Resend into the `Answer / Value` field.
4. Use the default TTL of `600`.
5. Select `Add Record`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-porkbun-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=7ef4c8c51fd01d854c6404b96b2a1a27)

Below is a mapping of the record fields from Resend to Porkbun:

| Porkbun | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Host | Name | `send` |
| Answer / Value | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL | TTL | `600` |

## Add TXT DKIM Records

On the same `Create Record` section:

1. On the `Type` page, choose `TXT`.
2. Type `resend._domainkey` for the `Host` of the record.
3. Copy the TXT Value Resend into the `Answer / Value` field.
4. Use the default TTL of `600`.
5. Select `Add Record`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-porkbun-dkim-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=9f3a33882f02d34489d5adc55f28c7b8)

Below is a mapping of the record fields from Resend to Porkbun:

| Porkbun | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Host | Name | `send` |
| Answer / Value | Content | `p=example_domain_key_value` |
| TTL | TTL | `600` |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

In the `DNS` section on Porkbun:

1. On the `Type` page, choose `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Host` of the record.
3. Copy the MX Value from Resend into the `Answer / Value` field.
4. Use the default TTL of `600`.
5. In the `Priority` field enter `10`.
6. Select `Add`.

Below is a mapping of the record fields from Resend to Porkbun:

| Porkbun | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Host | Name | `inbound` |
| Answer / Value | Content | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL | TTL | `600` |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Porkbun to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# AWS Route 53
Source: https://resend.com/docs/guides/dns/route53

Verify your domain on Route 53 with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to Route 53

Then, log in to your [AWS Management Console, and open Route 53 console](https://console.aws.amazon.com/route53/), then click on your domain name. From there, click on `Create Record`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-route53-createrecord.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=93d90903872f328b3f593e933d29f4fe)

## Add MX SPF Record

1. Type in `send` for the `Record name`.
2. Select the `Record type` dropdown, and choose `MX`.
3. Copy the MX Value from your domain in Resend into the `Value` field.
4. Be sure to include the `10` in the `Value` field, as seen in the screenshot.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-route53-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=8b798e983ecec8edb48c777143edfce5)

Below is a mapping of the record fields from Resend to Route 53:

| Route 53 | Resend | Example Value |
| - | - | - |
| Record Type | Type | `MX Record` |
| Record name | Name | `send` |
| Value | Content & Priority | `10 feedback-smtp.us-east-1.amazonses.com` |
| TTL | TTL | `Use Route 53 Default (300)` |
| Routing policy | - | `Simple routing` |

> [!NOTE]
>
> Route 53 does not label the `priority` column, and you will need to add this
> in to the `Value` section, as shown in the screenshot. Do not use the same
> priority for multiple records. If Priority `10` is already in use, try a
> number slightly higher like `11` or `12`.

## Add TXT SPF Record

In the same section, choose `Add another record`:

1. Type in `send` for the `Record name`.
2. Click the `Record type` dropdown.
3. Select the `Record type` dropdown, and choose `TXT`.
4. Copy TXT Value from your domain in Resend into the `Value` field.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-route53-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=79d4f534f637964bc06005f34cafe92b)

Below is a mapping of the record fields from Resend to Route 53:

| Route 53 | Resend | Example Value |
| - | - | - |
| Record type | Type | `TXT Record` |
| Record name | Name | `send` |
| Value | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL | TTL | `Use Route 53 Default (300)` |
| Routing policy | - | `Simple routing` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

## Add TXT DKIM Records

In the same section, choose `Add another record`:

1. Type in `resend._domainkey` for the `Record name`.
2. Change the `Record Type` to `TXT`.
3. Copy the TXT Value value from your domain in Resend to the `Value` text box.
4. Click on `Create Records`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-route53-dkim-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=00e9fa493cb8a6541fa0d16323b1a7af)

Below is a mapping of the record fields from Resend to Route 53:

| Route 53 | Resend | Example Value |
| - | - | - |
| Record type | Type | `TXT Record` |
| Record name | Name | `resend._domainkey` |
| Value | Content | `p=example_domain_key_value` |
| TTL | TTL | `Use Route 53 Default (300)` |
| Routing policy | - | `Simple routing` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

In the Route 53 console, click `Create Record`:

1. Type in `inbound` (or whatever your subdomain is) for the `Record name`.
2. Select the `Record type` dropdown, and choose `MX`.
3. Copy the MX Value from your domain in Resend into the `Value` field.
4. Be sure to include the `10` in the `Value` field (e.g., `10 inbound-smtp.us-east-1.amazonaws.com`).

Below is a mapping of the record fields from Resend to Route 53:

| Route 53 | Resend | Example Value |
| - | - | - |
| Record Type | Type | `MX Record` |
| Record name | Name | `inbound` |
| Value | Content & Priority | `10 inbound-smtp.us-east-1.amazonaws.com` |
| TTL | TTL | `Use Route 53 Default (300)` |
| Routing policy | - | `Simple routing` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take up to 5 hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Route 53 to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# Squarespace
Source: https://resend.com/docs/guides/dns/squarespace

Verify your domain on Squarespace with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to Squarespace

Log in to your [Squarespace domains page](https://account.squarespace.com/domains) and click on your domain.

![Domain Details](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/squarespace-domains-main.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=8362f1932f033cb983149883a9a459b6)

## Add MX SPF Record

Scroll down to the **Custom records** section and select `Add record` on Squarespace.

1. Type `send` for the `Host` of the record.
2. Set the `Type` to `MX`.
3. Set the `Priority` to `10`.
4. Use the Default 4 hours for `TTL`.
5. Copy the MX Value from Resend into the `Mail Server` field
6. Select `Save`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/squarespace-spf-mx.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=1222dfd2f85a612e61a52f15c2ac9818)

Below is a mapping of the record fields from Resend to Squarespace:

| Squarespace | Resend | Example Value |
| - | - | - |
| Type | Type | `MX` |
| Host | Name | `send` |
| TTL | TTL | `4 hrs` (default) |
| Mail Server | Content | `feedback-smtp.us-east-1.amazonses.com` |
| Priority | Priority | `10` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

> [!NOTE]
>
> Do not use the same priority for multiple records. If Priority `10` is already
> in use, try a higher value `20` or `30`.

## Add TXT SPF Record

In the same **Custom records** section, select `Add Record` on Squarespace.

1. Type `send` for the `Host` of the record.
2. Set the `Type` to `TXT`.
3. Use the Default 4 hours for `TTL`.
4. Copy the TXT Value from Resend into the `Text` field
5. Select `Save`.

Add the **TXT Record** from your domain in Resend to Squarespace and click "Save".

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/squarespace-spf-txt.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=13d1b0604c22b16161d1b99e9bc2f8d8)

Below is a mapping of the record fields from Resend to Squarespace:

| Squarespace | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT` |
| Host | Name | `send` |
| TTL | TTL | `4 hrs` (default) |
| Text | Content | `"v=spf1 include:amazonses.com ~all"` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

## Add TXT DKIM Records

In the same **Custom records** section, select `Add Record` on Squarespace.

1. Type `resend._domainkey` for the `Host` of the record.
2. Set the `Type` to `TXT`.
3. Use the Default 4 hours for `TTL`.
4. Copy the TXT Value from Resend into the `Text` field
5. Select `Save`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/squarespace-dkim-txt.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=119a6ade9688e65297e2dbff30e8256d)

Below is a mapping of the record fields from Resend to Squarespace:

| Squarespace | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT` |
| Host | Name | `resend._domainkey` |
| TTL | TTL | `4 hrs` (default) |
| Text | Content | `p=example_domain_key_value` |

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Scroll down to the **Custom records** section and select `Add record` on Squarespace:

1. Type `inbound` (or whatever your subdomain is) for the `Host` of the record.
2. Set the `Type` to `MX`.
3. Set the `Priority` to `10`.
4. Use the Default 4 hours for `TTL`.
5. Copy the MX Value from Resend into the `Mail Server` field.
6. Select `Save`.

Below is a mapping of the record fields from Resend to Squarespace:

| Squarespace | Resend | Example Value |
| - | - | - |
| Type | Type | `MX` |
| Host | Name | `inbound` |
| TTL | TTL | `4 hrs` (default) |
| Mail Server | Content | `inbound-smtp.us-east-1.amazonaws.com` |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take up to 72 hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Squarespace to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# Strato
Source: https://resend.com/docs/guides/dns/strato

Verify your domain on Strato with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Log in to Strato

Log in to your [Strato account](https://www.strato.es/apps/CustomerService):

1. In the left-hand navigation, go to Domains > Manage Domain.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-strato-domain-manager.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=684004473fd6679100907921ce2767df)

## Add MX SPF Record

1. On the domain page, click on the gear icon to redirect to Settings.
2. Create a new subdomain named `send`.
3. Navigate to the subdomain settings.
4. Go to the `DNS` tab, you'll see a list of DNS records you can update. Click on `manage` MX record.
5. Select own mail server.
6. Copy MX value from Resend into `Server` field.
7. Use the default priority `Low`.
8. Save settings.

> [!NOTE]
>
> By default, Strato domains use Strato mail server which uses `mail` as their
> send path. You will need to bypass this default behavior by creating a
> subdomain and setting the MX record there.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-strato-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=9c884d56f98f468503cb10d28b6cd60f)

Below is a mapping of the record fields from Resend to Strato:

| Strato | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `send` |
| Mail server | Content | `feedback-smtp.eu-west-1.amazonses.com.` |
| Priority | Priority | `Low` |

## Add TXT SPF Record

On the base domain settings:

1. Go to the `DNS` tab.
2. Manage TXT and CNAME records.
3. On the bottom, click `Create another record`.
4. Choose `TXT` type.
5. Add `send` for the `name` record.
6. For `value` input `v=spf1 include:amazonses.com ~all`.
7. Save settings.

> [!NOTE]
>
> Strato provides a standard DMARC record similar to Resend's recommended value:
> `v=DMARC1;p=reject;`.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-strato-spf-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=d3484aaa1f6eda375fce393939d69ada)

Below is a mapping of the record fields from Resend to Strato:

| Strato | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send` |
| Value | Content | `v=spf1 include:amazonses.com ~all` |

## Add TXT DKIM Records

On the same TXT and CNAME manage page:

1. Click `Create another record`.
2. Choose `TXT` type.
3. Add `resend._domainkey` for the `Name` record.
4. Copy the record value from Resend into the TXT value field.
5. Save settings.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-strato-spf-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=d3484aaa1f6eda375fce393939d69ada)

Below is a mapping of the record fields from Resend to Strato:

| Strato | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send` |
| Value | Content | `p=example_domain_key_value` |

> [!NOTE]
>
> Copy DKIM value using the small copy icon in Resend. DKIM records are
> case-sensitive and must match up exactly.

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

1. Create a new subdomain named `inbound` (or whatever your subdomain is).
2. Navigate to the subdomain settings.
3. Go to the `DNS` tab and click on `manage` MX record.
4. Select own mail server.
5. Copy MX value from Resend into `Server` field.
6. Use the default priority `Low`.
7. Save settings.

Below is a mapping of the record fields from Resend to Strato:

| Strato | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `inbound` |
| Mail server | Content | `inbound-smtp.us-east-1.amazonaws.com.` |
| Priority | Priority | `Low` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Strato to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# Vercel
Source: https://resend.com/docs/guides/dns/vercel

Verify your domain on Vercel with Resend.

> [!NOTE]
>
> This guide helps you verify your domain on Vercel with Resend. We also have
> [an official integration for
> Vercel](https://resend.com/blog/vercel-integration) that helps you set up your
> API keys on Vercel projects so you can start sending emails with Resend. [View
> the integration here](https://vercel.com/resend/~/integrations/resend).

## Vercel Marketplace integration

If you installed Resend through the [Vercel Marketplace](https://vercel.com/marketplace/resend), Vercel manages the lifecycle of your Resend team, API keys, and domains. These resources cannot be deleted from the Resend dashboard, as they must uninstalled from Vercel to remove them.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-add-domain.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=418dd93c2f2ead0b0d83d1b7c2fb0970)

> [!TIP]
>
> It is [best practice to use a
> subdomain](/docs/dashboard/domains/introduction#subdomains) (updates.example.com)
> instead of the root domain (example.com). Using a subdomain allows for proper
> reputation segmentation based on topics or purpose (e.g. marketing) and is
> especially important if receiving emails with Resend.

## Automatic Setup (Recommended)

The fastest way to verify your domain on Vercel is using the **Auto Configure** button on Resend. This uses Domain Connect to automatically configure your DNS records.

1. Go to your [Domains page](https://resend.com/domains) in Resend.
2. (Optional) If you want to receive emails, select `Manual setup` and toggle the "Receiving" switch on the domain details page. ([Learn more below](#receiving-emails))
3. Click **Auto Configure**.
4. Authorize Resend to access your Vercel DNS settings.
5. The DNS records will be added automatically.

<video aria-label="Vercel Domain Connect Setup" />

That's it. Your domain will be verified within a few minutes.

## Manual Setup

If you prefer to add DNS records manually, follow these steps.

### Log in to Vercel

Log in to your [Vercel account](https://vercel.com/login) and select the `Domains` tab.

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-vercel-domains.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=4b4ab73110a36775175b39587eea68f0)

## Add MX SPF Record

Copy and paste the values in Resend to Vercel.

1. Type `send` for the `Name` of the record in Vercel.
2. Expand the `Type` dropdown and select `MX`.
3. Copy the record value from Resend into the `Value` field in Vercel.
4. Add `10` for the `Priority`.
5. Select `Add`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=bb0db2dd2809135194cfb62b695225cd)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-vercel-spf-mx.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=9d91de47106d0bd4005bac0cfe68779e)

Below is a mapping of the record fields from Resend to Vercel:

| Vercel | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `send` |
| Value | Content | `feedback-smtp.us-east-1.amazonses.com` |
| TTL | TTL | `Use Vercel default (60)` |
| Priority | Priority | `10` |

> [!NOTE]
>
> Do not use the same priority for multiple records. If Priority `10` is already
> in use on another record, try a higher value `20` or `30`.

## Add TXT SPF Record

In the same section, add another record in Vercel.

1. Type `send` for the `Name` of the record.
2. Expand the `Type` dropdown and select `TXT`.
3. Copy the `TXT` record value from Resend into the `Value` field in Vercel.
4. Use the default TTL of `60`.
5. Select `Add`.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
> subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=747425d0a224baeee2846c9a707d5bbc)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-vercel-spf-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=27b350fc1a7745dd47c623fdaf9a2df4)

Below is a mapping of the record fields from Resend to Vercel:

| Vercel | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `send` |
| Value | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL | TTL | `Use Vercel default (60)` |

## Add TXT DKIM Records

In the same section, add another record in Vercel.

1. Type `resend._domainkey` for the `Name` of the record.
2. Expand the `Type` dropdown and select `TXT`.
3. Copy the record value from Resend into the `Value` field in Vercel.

> [!NOTE]
>
> Omit your domain from the record values in Resend when you paste. Instead of
> `resend._domainkey.example.com`, paste only `resend._domainkey` (or
> `resend._domainkey.subdomain` if you're using a subdomain).

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-resend-dkim.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=345d1dc6b7c138dbd92bd6928c634bd9)

![Domain Details](https://mintcdn.com/resend/JHWt09hsc7E33HK2/images/dashboard-domains-vercel-dkim-txt.png?fit=max\&auto=format\&n=JHWt09hsc7E33HK2\&q=85\&s=8553d093e572970b0335c1fe9b83e003)

Below is a mapping of the record fields from Resend to Vercel:

| Vercel | Resend | Example Value |
| - | - | - |
| Type | Type | `TXT Record` |
| Name | Name | `resend._domainkey` |
| Value | Content | `p=example_domain_key_value` |
| TTL | TTL | `Use Vercel default (60)` |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

![Enable Receiving Emails for a verified domain](https://mintcdn.com/resend/B7wTVm7aKL5pNT-6/images/inbound-domain-toggle.png?fit=max\&auto=format\&n=B7wTVm7aKL5pNT-6\&q=85\&s=46f6b4c142fb90e04b57861e338ed2d0)

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

> [!NOTE]
>
> Always copy the MX record value shown on your domain's page in Resend. The
> values in this guide are examples. Depending on your domain you will see
> `receive.forge.rmta.net`, a regional variant such as
> `receive-euw1.forge.rmta.net`, or `inbound-smtp.<region>.amazonaws.com`.

Copy and paste the values in Resend to Vercel:

1. Type `inbound` (or whatever your subdomain is) for the `Name` of the record in Vercel.
2. Expand the `Type` dropdown and select `MX`.
3. Copy the MX Value from Resend into the `Value` field in Vercel.
4. Add `10` for the `Priority`.
5. Select `Add`.

Below is a mapping of the record fields from Resend to Vercel:

| Vercel | Resend | Example Value |
| - | - | - |
| Type | Type | `MX Record` |
| Name | Name | `inbound` |
| Value | Content | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL | TTL | `Use Vercel default (60)` |
| Priority | Priority | `10` |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/docs/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

> [accordion] Resend shows my domain verification failed.
>
> Review the records you added to Vercel to rule out copy and paste errors.

> [accordion] It has been longer than 72 hours and my domain is still Pending.
>
> [Review our guide on a domain not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying).


# Inbox Agent
Source: https://resend.com/docs/guides/inboxes/agent

Learn how to configure and use the built-in Inbox agent.

Every inbox has a built-in agent that can triage incoming email for you. You describe how the inbox should be handled, choose which actions the agent is allowed to take, and the agent acts on each new email that arrives.

## How the agent works

When a new email arrives in an inbox, the agent reads it alongside your instructions and decides which of its enabled actions to take, if any. The agent runs once the inbox has instructions and at least one enabled action.

The agent does not act on threads in the spam folder, and it skips emails that need no action.

> [!NOTE]
>
> The agent never sends email on its own. Replies and forwards are saved as
> [drafts](/docs/guides/inboxes/drafts) for a member of your team to review and send.

## Configure the agent

### Using the dashboard

**1. Open an inbox and click the **Settings** button.**

**2. Select the **Customize** tab.**

If the inbox is empty, you can also click **Set up agent**.

**3. Write your **Instructions**.**

Describe how the agent should handle email in this inbox, in up to 4,000
characters. Click the suggestion button for an example to start from.

**4. Choose the **Available actions**.**

Select the actions the agent is allowed to take, or choose **All actions**.

**5. Set the **Tone of voice**.**

Choose how concise or expanded, and how professional or casual, the agent's
writing should be. The preview shows how replies will sound.

Changes are saved automatically as you make them.

### Using the API

You can also [update the agent settings](/docs/api-reference/inboxes/update-agent) via the API, SDKs, or CLI. Fields you leave out keep their current value, and `actions` replaces the whole set of actions. The `tone` is one of `concise_professional`, `concise_casual`, `expanded_professional`, or `expanded_casual`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.agent.update({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  instructions: 'Answer refund questions yourself. Escalate legal threats.',
  tone: 'concise_professional',
  actions: ['draft_reply', 'add_labels'],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->agent->update('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'instructions' => 'Answer refund questions yourself. Escalate legal threats.',
  'tone' => 'concise_professional',
  'actions' => ['draft_reply', 'add_labels'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Agent.UpdateParams = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "instructions": "Answer refund questions yourself. Escalate legal threats.",
  "tone": "concise_professional",
  "actions": ["draft_reply", "add_labels"],
}

resend.Inboxes.Agent.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "instructions": "Answer refund questions yourself. Escalate legal threats.",
  "tone": "concise_professional",
  "actions": ["draft_reply", "add_labels"],
}

Resend::Inboxes::Agent.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	instructions := "Answer refund questions yourself. Escalate legal threats."
	tone := resend.InboxAgentToneConciseProfessional

	params := &resend.UpdateInboxAgentRequest{
		Instructions: &instructions,
		Tone:         &tone,
		Actions: []resend.InboxAgentAction{
			resend.InboxAgentActionDraftReply,
			resend.InboxAgentActionAddLabels,
		},
	}

	client.Inboxes.Agent.Update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::{InboxAgentAction, InboxAgentTone, UpdateInboxAgentOptions}, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let update = UpdateInboxAgentOptions::new()
    .with_instructions("Answer refund questions yourself. Escalate legal threats.")
    .with_tone(InboxAgentTone::ConciseProfessional)
    .with_actions([InboxAgentAction::DraftReply, InboxAgentAction::AddLabels]);

  let _agent = resend
    .inboxes
    .update_agent("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", update)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.InboxAgentAction;
import com.resend.services.inboxes.model.InboxAgentTone;
import com.resend.services.inboxes.model.UpdateInboxAgentOptions;
import com.resend.services.inboxes.model.UpdateInboxAgentResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxAgentOptions params = UpdateInboxAgentOptions.builder()
                .instructions("Answer refund questions yourself. Escalate legal threats.")
                .tone(InboxAgentTone.CONCISE_PROFESSIONAL)
                .actions(InboxAgentAction.DRAFT_REPLY, InboxAgentAction.ADD_LABELS)
                .build();

        UpdateInboxAgentResponseSuccess data = resend.inboxes().agent().update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxAgentUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxAgentUpdateData()
    {
        Instructions = "Answer refund questions yourself. Escalate legal threats.",
        Tone = InboxAgentTone.ConciseProfessional,
        Actions = new List<InboxAgentAction>
        {
            InboxAgentAction.DraftReply,
            InboxAgentAction.AddLabels,
        },
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/agent' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "instructions": "Answer refund questions yourself. Escalate legal threats.",
  "tone": "concise_professional",
  "actions": ["draft_reply", "add_labels"]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes agent update \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --instructions "Answer refund questions yourself. Escalate legal threats." \
  --tone concise_professional \
  --actions draft_reply add_labels
```

To see the current settings, [retrieve the agent settings](/docs/api-reference/inboxes/get-agent).

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.agent.get({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->agent->get('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Agent.get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes::Agent.get({ "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" })
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Agent.Get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _agent = resend
    .inboxes
    .get_agent("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.GetInboxAgentResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        GetInboxAgentResponseSuccess data = resend.inboxes().agent().get("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxAgentRetrieveAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
Console.WriteLine( "Agent tone={0}", resp.Content.Tone );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/agent' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes agent get --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1
```

## Actions

The available actions are:

| Dashboard name | API value | What the agent does |
| - | - | - |
| Draft replies | `draft_reply` | Writes a reply as a draft for you to review and send. |
| Forward threads | `forward_thread` | Writes a forward as a draft for you to review and send. |
| Add labels | `add_labels` | Applies existing [labels](/docs/guides/inboxes/labels) to the thread. |
| Assign threads to teammates | `assign_thread` | Assigns the thread to a member of your team. |
| Mark as spam | `mark_as_spam` | Moves the thread to the spam folder. |
| Archive | `archive` | Moves the thread to the archive folder. |
| Move to trash | `move_to_trash` | Moves the thread to the trash folder. |

A few rules keep the agent's actions safe:

* **Drafts are never overwritten.** If a thread already has a draft, the agent leaves it alone and does not draft a reply or forward.
* **Forwards only go to addresses in your instructions.** Write out the full email address the agent should forward to. Naming a domain or a person is not enough.
* **Assignments need a clear match.** Name the teammate by email address or name in your instructions. If the name matches nobody, or more than one person, the thread is not assigned.
* **Labels must already exist.** The agent applies your existing labels but does not create new ones. [Create the labels](/docs/guides/inboxes/labels#create-a-label) you want it to use first.

## Security

Anyone who knows an inbox address can send it email, including people who write instructions for the agent into an email, an attack known as prompt injection. The agent has these safeguards built in:

* **Email content is data, not instructions.** The agent reads the subject, body, and sender name of every email as untrusted data. It ignores any instructions they contain, and it follows only your instructions. Label names are treated the same way.
* **It never sends email.** Replies and forwards are saved as [drafts](/docs/dashboard/inboxes/drafts), so a person reviews every message before it leaves the inbox.
* **Forward recipients are checked.** A forward to any address that isn't written out in your instructions is rejected, even when an email asks for it. Lookalike addresses don't match.
* **Important email stays in the inbox.** Each new email is checked to see whether it needs your attention. When it does, the agent can't archive it, move it to trash, or mark it as spam.
* **It only uses the actions you enable.** The agent has no access to actions you haven't selected, and it doesn't act on threads in the spam folder.

You also control how much the agent can do. To keep it safe:

* **Enable only the actions you need.** An agent that only adds labels and drafts replies can't move or forward email.
* **Keep secrets out of your instructions.** A draft reply goes back to the sender, so don't include anything in your instructions that you don't want a sender to see, such as internal links, credentials, or customer data.
* **Don't trust the sender's address.** Email addresses and display names can be spoofed, so don't write instructions that give a sender special treatment based on who the email claims to be from.
* **Review drafts before you send them.** Check the recipients and the content of each agent draft, especially forwards.

> [!NOTE]
>
> These safeguards apply to the built-in agent. If you build your own agent on
> [inbox webhooks](/docs/webhooks/inboxes/email-received), see the [Agent Email Inbox
> skill](/docs/agent-email-inbox-skill) for security patterns.

## Writing instructions

Clear, specific instructions get the best results. Tell the agent what kinds of email to expect, and what to do with each. For example:

```text theme={"theme":{"light":"github-light","dark":"vesper"}}
This inbox receives support requests for our online store.

- Label anything about billing or refunds with "Billing".
- Label anything that mentions a legal threat with "Urgent" and assign it to ada@example.com.
- Draft replies to questions about order status, pointing them to https://example.com/orders.
- Forward partnership enquiries to partners@example.com.
- Archive newsletters and automated notifications.
```

## Review the agent's work

The agent's work shows up directly in the inbox. Threads it labels, assigns or moves appear with those changes applied, and you can undo any of them by [organizing the thread](/docs/guides/inboxes/threads#organize-threads) yourself.

When you open a thread that the agent drafted a reply or forward for, the draft opens in the reply composer with a badge showing it was drafted by the agent. Edit the draft if needed, then click **Send**, or discard it.

## Disable the agent

To stop the agent from acting on new email, remove all of its available actions or clear its instructions. Via the API, send an empty `actions` array.

## API Reference

For complete API documentation, see the [Inbox Agent API reference](/docs/api-reference/inboxes/get-agent).


# Build a support inbox from a contact form
Source: https://resend.com/docs/guides/inboxes/build-a-support-inbox

Send contact form submissions to a Resend Inbox, and let the inbox agent label each request and draft a reply.

Most websites have a contact form, and most contact forms send their submissions to an email address that someone has to check. In this guide, you send each submission to a Resend [Inbox](/docs/dashboard/inboxes/introduction) instead. Every submission becomes a thread, the [inbox agent](/docs/dashboard/inboxes/agent) labels it and drafts a reply, and your team reviews the draft and sends it from the Dashboard.

```mermaid theme={"theme":{"light":"github-light","dark":"vesper"}}
flowchart LR
    A[Contact form] --> B[Server Action]
    B --> C[Inbox]
    C --> D[Agent labels<br>and drafts]
    D --> E[Your team<br>sends the reply]
```

The guide has three parts:

1. **[Set up the inbox](#set-up-the-inbox):** create the inbox, its labels, and the inbox agent.
2. **[Add the contact form](#add-the-contact-form):** build a form in a Next.js app that sends each submission to the inbox.
3. **[Test the flow](#test-the-flow):** submit the form, then review and send the agent's draft.

Prefer watching a video? Check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/Gyp6dJjJyoc)

Each part uses prompts you copy into an AI agent. In the first part, the agent is connected to the [Resend MCP server](/docs/mcp-server) and makes the calls for you. You can set up the inbox another way:

* **Dashboard:** [create the inbox](/docs/dashboard/inboxes/create-inboxes), [add labels](/docs/dashboard/inboxes/labels#create-a-label), and [configure the agent](/docs/dashboard/inboxes/agent#using-the-dashboard) in the [Inboxes dashboard](https://resend.com/inboxes).
* **API:** call [Create Inbox](/docs/api-reference/inboxes/create-inbox), [Create Label](/docs/api-reference/inboxes/create-label), and [Update Agent](/docs/api-reference/inboxes/update-agent).
* **SDKs:** make the same calls from any of the [Resend SDKs](/docs/sdks).

> [!NOTE]
>
> Every account includes 3 inboxes for free. See
> [pricing](https://resend.com/pricing#inboxes) for details.

## Prerequisites

* An AI agent, such as Claude, Claude Code, Cursor, or Codex. You connect it to Resend in the first step.
* A verified [subdomain](/docs/dashboard/domains/introduction#subdomains), such as `help.example.com`, with [receiving enabled](/docs/dashboard/receiving/custom-domains). The inbox address and the form's sending address both use this subdomain.
* [Node.js](https://nodejs.org/) installed.

## Set up the inbox

Start with the inbox itself. By the end of this part, the inbox exists, it has labels, and the agent is ready to label and draft a reply for each new thread.

**1. Connect your agent to Resend**

If your client supports it, install the Resend plugin. It adds the [Resend MCP server](/docs/mcp-server) and the [Resend skills](/docs/resend-skill) in one step. The MCP server lets your agent set up the inbox, and the skills give it Resend's recommendations when it writes the contact form code later in this guide. Find the install for your client in the [MCP server setup](/docs/mcp-server#remote-mcp-server).

If your client doesn't support plugins, connect the MCP server on its own. The remote server at `https://mcp.resend.com/mcp` signs you in to Resend with OAuth, so the setup prompts don't need an API key.

**2. Create the inbox**

Create the inbox on a verified subdomain, such as `help.example.com`, instead of your root domain. A subdomain keeps the inbox's [sending reputation](/docs/dashboard/domains/introduction#subdomains) separate from your other email, and its MX record doesn't affect an email service that already receives mail for your root domain.

Copy this prompt into your agent. It lists your verified subdomains so you can pick the one to use:

```markdown Prompt wrap theme={"theme":{"light":"github-light","dark":"vesper"}}
Use the Resend MCP server to create an inbox. First, offer my verified subdomains with sending and receiving enabled so I can pick one to set up an inbox named "Support". Ideally, the subdomain would be `help` or something that indicates a support intent (e.g., support@help.example.com).

- If I don't have any subdomains with receiving enabled, stop and tell me what's missing. Don't create the inbox on the root domain instead.
- If an inbox with that address already exists, use it instead of creating a new one.
```

The new inbox appears in the [Inboxes dashboard](https://resend.com/inboxes), with no threads yet.

![The new support inbox in the dashboard, with no emails yet](https://mintcdn.com/resend/Oq_pCMc2QJKDAevz/images/build-a-support-inbox-1.png?fit=max\&auto=format\&n=Oq_pCMc2QJKDAevz\&q=85\&s=a3b47fb0f20d6747b134c9a45ec684c9)

**3. Create the labels**

The agent only applies labels that already exist, so create them before you turn it on:

```markdown Prompt wrap theme={"theme":{"light":"github-light","dark":"vesper"}}
Use the Resend MCP server to create these labels on my inbox named "Support". If you can't find it, stop and ask me. Skip any label that already exists.

- Billing
- Bug report
- Feature request
- Urgent
```

**4. Turn on the agent**

This prompt gives the agent its instructions, a tone, and the actions it can take:

```markdown Prompt wrap theme={"theme":{"light":"github-light","dark":"vesper"}}
Use the Resend MCP server to update the agent on my inbox named "Support". If you can't find it, stop and ask me. Set the tone to concise_professional, enable only the draft_reply and add_labels actions, and set the instructions to exactly this text:

This inbox receives support requests from the contact form on our website.

- Label questions about invoices, payments, plans or refunds with "Billing".
- Label reports of something broken or not working as expected with "Bug report".
- Label requests for new functionality with "Feature request".
- Also label anything that mentions a security issue, data loss or a legal threat with "Urgent".
- Draft a reply to every request. Thank the person, restate their question in one sentence, and tell them a member of the team will follow up within one business day.
- Never promise refunds, discounts, dates or fixes.
```

The agent only gets `draft_reply` and `add_labels`. It can't send email, and it can't move threads out of the inbox, so nothing reaches a customer or disappears without a person seeing it first.

To check the result, open the inbox, click **Settings**, and select the **Customize** tab. The instructions, actions, and tone match what the agent set.

![The Customize tab of the Support inbox settings, with the support instructions, 2 available actions, and a concise, professional tone](https://mintcdn.com/resend/Oq_pCMc2QJKDAevz/images/build-a-support-inbox-2.png?fit=max\&auto=format\&n=Oq_pCMc2QJKDAevz\&q=85\&s=a8dc621b3092680d6d748d39fabba309)

## Add the contact form

The inbox is ready, but nothing sends email to it yet. In this part, you create a Next.js app with a contact form that sends each submission to the inbox from a Server Action.

**1. Create a Next.js app**

Give your coding agent this prompt to create a new project:

```markdown Prompt wrap theme={"theme":{"light":"github-light","dark":"vesper"}}
Create a new Next.js app named support-form with TypeScript, the App Router, and the src directory. Then install the Resend Node.js SDK `resend` package.
```

> [!TIP]
>
> To add the form to a Next.js app you already have, skip this step, install the
> `resend` package, and run the next steps in that app.

**2. Add your API key**

The form needs an API key that can only send email, and only from your subdomain. Create it in the [API keys dashboard](https://resend.com/api-keys): click **Create API key**, choose **Sending access**, and select your subdomain. See [API keys](/docs/dashboard/api-keys/introduction) for details.

Resend only shows the key once, when it's created. Add it to your app's environment as `RESEND_API_KEY`:

```bash .env.local theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY=re_xxxxxxxxx
```

> [!NOTE]
>
> The Resend MCP server can also create API keys, but the key then passes
> through your agent's context and can end up in the session's transcript.

**3. Build the form**

Give your coding agent this prompt. It uses the Resend MCP server to look up the address of the inbox you created:

```markdown Prompt wrap theme={"theme":{"light":"github-light","dark":"vesper"}}
Use the Resend MCP server to find the address of my inbox named "Support". If you can't find it, stop and ask me. Don't guess or use a placeholder. Then add a contact form to this Next.js app at /support, with name, email, and message fields. Submit it to a Server Action that uses the Resend Node.js SDK and RESEND_API_KEY to send the submission to that inbox:

- Send to the inbox address, from `Website contact form <forms@...>` on the same subdomain as the inbox. The from address must be different from the inbox address.
- Write both addresses into the Server Action as constants, using the real inbox address you found. Don't read them from environment variables, and don't use sample values like example.com.
- Set replyTo to the email address the visitor entered.
- Use the subject `Support request from ${name}` and send the name, email, and message as plain text. Never render the visitor's input as HTML.
- Never send email to the address the visitor entered.
- Check the length of each field and the format of the email address, and remove line breaks from the name.
- Add a honeypot field named "website" that's hidden from people. If it's filled in, return success without sending.
- Limit each IP address to 3 submissions every 10 minutes.
```

When your agent finishes, the Server Action includes a send like this one, with your inbox's address:

```ts src/app/support/actions.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
const { error } = await resend.emails.send({
  from: 'Website contact form <forms@help.example.com>',
  to: ['support@help.example.com'],
  replyTo: email,
  subject: `Support request from ${name}`,
  text: `Name: ${name}\nEmail: ${email}\n\n${message}`,
});
```

Two details make this work:

* **`replyTo` is the visitor's address.** Replies from the inbox, including the agent's drafts, go to the reply-to address instead of the form's sending address. Your team replies to the visitor directly from the thread.
* **The submission arrives as a new email.** Because it's sent to the inbox from another address, it lands in the **Inbox** folder as a new thread and the agent runs on it.

## Test the flow

With the inbox and the form in place, send a test submission through the whole flow.

**1. Submit the form**

Start your app with `npm run dev`, open [http://localhost:3000/support](http://localhost:3000/support), and submit the form with an email address you can check. If your app runs on a different port, or you added the form at a different route, use that URL instead.

Use this message to test it. It's a billing question, so the agent should apply the "Billing" label:

```text Message theme={"theme":{"light":"github-light","dark":"vesper"}}
Hi, I was charged twice for my Pro plan this month. Can you check my last two invoices and let me know if one of them will be refunded?
```

**2. Check the thread**

Ask your MCP-connected agent to check the result:

```markdown Prompt wrap theme={"theme":{"light":"github-light","dark":"vesper"}}
Use the Resend MCP server to show me the most recent thread in my inbox named "Support": its labels, the email it contains, and any draft reply the inbox agent wrote. Don't send the draft.
```

Open the thread in the [Inboxes dashboard](https://resend.com/inboxes). It has a label and a draft reply written by the agent.

![A support thread in the dashboard with the Billing label and a draft reply written by the agent](https://mintcdn.com/resend/Oq_pCMc2QJKDAevz/images/build-a-support-inbox-3.png?fit=max\&auto=format\&n=Oq_pCMc2QJKDAevz\&q=85\&s=7dd87ea6347cddcaccaefc5ffde8ba6a)

**3. Send the reply**

Edit the draft if needed, and click **Send**. The reply arrives at the address you entered in the form, and any answer from that address continues the same thread.

## Protect the form

Anyone can submit a public form. The form prompt limits what a bot or an attacker can do with it:

* **No automatic confirmation.** The form never emails the address a visitor enters, so no one can use it to send email from your domain to a stranger.
* **Honeypot field.** Bots that fill in the hidden `website` field get a success message, and nothing is sent.
* **Rate limit.** Each IP address can submit 3 times every 10 minutes. In production, use a shared store such as [Upstash Redis](https://upstash.com/docs/redis/sdks/ratelimit-ts/overview), since an in-memory limit only counts on one server instance.
* **Checked, plain-text input.** Fields have length limits, the name has no line breaks, and nothing a visitor enters is rendered as HTML.

## How the agent handles untrusted email

Anyone can write to your form, including people who try to give the agent instructions. The agent is built to handle that:

* It treats every email as data, never as instructions.
* It never sends email. Replies are saved as drafts for your team to review.
* It only uses the actions you enable, here `draft_reply` and `add_labels`.

See [Inbox agent security](/docs/dashboard/inboxes/agent#security) for the full list of safeguards.

## Next steps

* **Assign urgent requests.** Ask your agent to add `assign_thread` to the inbox agent's actions, and name the teammate by email address in the instructions, for example `Assign "Urgent" threads to ada@example.com`.
* **Get notified when a draft is ready.** Subscribe to the [`inbox.draft.created`](/docs/webhooks/inboxes/draft-created) webhook event, and post a message to your team chat with a link to the thread. The agent's draft is ready by the time someone opens it.
* **Tune the agent.** Ask your agent to change the instructions or tone, edit them in the inbox settings in the dashboard, or update them through the [Inbox Agent API](/docs/api-reference/inboxes/update-agent).


# Creating Inboxes
Source: https://resend.com/docs/guides/inboxes/create-inboxes

Learn how to create inboxes in Resend.

An inbox is an email address on a [verified domain](/docs/dashboard/domains/introduction). Once it exists, it can send email and collect replies in threads.

## Before you create an inbox

* [Add and verify a domain](/docs/dashboard/domains/introduction) for sending. The inbox address must use that domain.
* To receive email at the inbox, the domain also needs [receiving enabled with an MX record](/docs/dashboard/receiving/custom-domains#enabling-receiving-for-an-existing-domain). If you can't change the MX record, [set up forwarding](#forward-an-existing-address) instead.
* Inboxes are billed separately from the rest of your plan. When you create an inbox in the dashboard, Resend shows what applies to your account. See [pricing](https://resend.com/pricing#inboxes) for details.

## Create an inbox

### Using the dashboard

**1. Navigate to the Inboxes Dashboard page.**

The [Inboxes page](https://resend.com/inboxes) shows all of your existing
inboxes, and allows you to add new ones.

**2. Click the **Create inbox** button.**

![Create inbox](https://mintcdn.com/resend/2wyYbavX_c3s0W4P/images/inboxes-create.png?fit=max\&auto=format\&n=2wyYbavX_c3s0W4P\&q=85\&s=9a7716bb0de50e1a6efe64460fabac5b)

**3. Enter the address.**

Type the part before the `@`, for example `support`.

**4. Choose the domain from your list of verified domains.**

![Choose an address and domain](https://mintcdn.com/resend/2wyYbavX_c3s0W4P/images/inboxes-create-2.png?fit=max\&auto=format\&n=2wyYbavX_c3s0W4P\&q=85\&s=7041e9dcbb51c8031fc9553c171abf16)

**5. Start sending emails from your new inbox.**

![The new inbox is ready for you to compose your first
email.](https://mintcdn.com/resend/2wyYbavX_c3s0W4P/images/inboxes-create-3.png?fit=max\&auto=format\&n=2wyYbavX_c3s0W4P\&q=85\&s=f4a193c17e707a162a4558d2825a5008)

### Using the API

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.create({
  emailAddress: 'support@example.com',
  name: 'Customer Support',
  fromName: 'Ada from Support',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->create([
  'email_address' => 'support@example.com',
  'name' => 'Customer Support',
  'from_name' => 'Ada from Support',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.CreateParams = {
  "email_address": "support@example.com",
  "name": "Customer Support",
  "from_name": "Ada from Support",
}

resend.Inboxes.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "email_address": "support@example.com",
  "name": "Customer Support",
  "from_name": "Ada from Support",
}

Resend::Inboxes.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateInboxRequest{
		EmailAddress: "support@example.com",
		Name:         "Customer Support",
		FromName:     "Ada from Support",
	}

	client.Inboxes.Create(params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateInboxOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let inbox = CreateInboxOptions::new("support@example.com")
    .with_name("Customer Support")
    .with_from_name("Ada from Support");

  let _inbox = resend.inboxes.create(inbox).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.CreateInboxOptions;
import com.resend.services.inboxes.model.CreateInboxResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateInboxOptions params = CreateInboxOptions.builder()
                .emailAddress("support@example.com")
                .name("Customer Support")
                .fromName("Ada from Support")
                .build();

        CreateInboxResponseSuccess data = resend.inboxes().create(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxCreateAsync( new InboxCreateData()
{
    EmailAddress = "support@example.com",
    Name = "Customer Support",
    FromName = "Ada from Support",
} );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "email_address": "support@example.com",
  "name": "Customer Support",
  "from_name": "Ada from Support"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes create \
  --email-address support@example.com \
  --name "Customer Support" \
  --from-name "Ada from Support"
```

## Forward an existing address

If your domain is not verified for receiving emails you have two options. You can either [enable receiving for your domain with an MX record](/docs/dashboard/receiving/custom-domains#enabling-receiving-for-an-existing-domain) or set up forwarding. The Dashboard makes these options available to you.

If you are using the API and you can't add an MX record for the domain, set `forwarding` to `true` when creating the inbox. Resend provisions a receiving address for the inbox. [Retrieve the inbox](/docs/api-reference/inboxes/get-inbox) to read its `receiving_address`, then forward your existing mailbox to that address. Forwarded emails arrive in the inbox as threads.

> [!NOTE]
>
> Forwarding is useful when your domain's MX records already point at another
> mail provider and you don't want to change them.

## API Reference

For complete API documentation, see the [Inboxes API reference](/docs/api-reference/inboxes/create-inbox).


# Inbox Drafts
Source: https://resend.com/docs/guides/inboxes/drafts

Learn how to create, update, and send draft emails in the inbox.

A draft is an unsent email in an inbox. A draft can start a new conversation, or be a reply to an email in an existing thread. Drafts are shared with your team, so anyone can pick up a draft, edit it and send it.

## Create a draft

### Using the dashboard

**1. Open an inbox.**

Select an inbox from the [Inboxes dashboard](https://resend.com/inboxes).

**2. Click the **Compose** button.**

You can also press <kbd>C</kbd>.

**3. Enter the recipients, subject and message.**

Click **Cc** or **Bcc** to add more recipients. You can add up to 50
recipients in total.

The draft saves automatically as you write, so there is no save button. You can minimize the composer and return to it later from the **Drafts** folder.

To reply to or forward an email in a thread, use the **Reply**, **Reply all** or **Forward** buttons while viewing the thread. The reply opens inline beneath the email and is also saved as a draft as you write.

### Using the API

Omit `thread_id` to create a draft for a new conversation.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.create({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  to: ['ada@example.com'],
  subject: 'Refund for order 1041',
  html: '<p>Refund issued for order 1041.</p>',
  text: 'Refund issued for order 1041.',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->create('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'to' => ['ada@example.com'],
  'subject' => 'Refund for order 1041',
  'html' => '<p>Refund issued for order 1041.</p>',
  'text' => 'Refund issued for order 1041.',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Drafts.CreateParams = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "to": ["ada@example.com"],
  "subject": "Refund for order 1041",
  "html": "<p>Refund issued for order 1041.</p>",
  "text": "Refund issued for order 1041.",
}

resend.Inboxes.Drafts.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "to": ["ada@example.com"],
  "subject": "Refund for order 1041",
  "html": "<p>Refund issued for order 1041.</p>",
  "text": "Refund issued for order 1041.",
}

Resend::Inboxes::Drafts.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateInboxDraftRequest{
		To:      []string{"ada@example.com"},
		Subject: "Refund for order 1041",
		Html:    "<p>Refund issued for order 1041.</p>",
		Text:    "Refund issued for order 1041.",
	}

	client.Inboxes.Drafts.Create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateInboxDraftOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let draft = CreateInboxDraftOptions::new()
    .with_to(["ada@example.com"])
    .with_subject("Refund for order 1041")
    .with_html("<p>Refund issued for order 1041.</p>")
    .with_text("Refund issued for order 1041.");

  let _draft = resend
    .inboxes
    .create_draft("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", draft)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.CreateInboxDraftOptions;
import com.resend.services.inboxes.model.CreateInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateInboxDraftOptions params = CreateInboxDraftOptions.builder()
                .to("ada@example.com")
                .subject("Refund for order 1041")
                .html("<p>Refund issued for order 1041.</p>")
                .text("Refund issued for order 1041.")
                .build();

        CreateInboxDraftResponseSuccess data = resend.inboxes().drafts().create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxDraftCreateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxDraftCreateData()
    {
        To = "ada@example.com",
        Subject = "Refund for order 1041",
        HtmlBody = "<p>Refund issued for order 1041.</p>",
        TextBody = "Refund issued for order 1041.",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "to": ["ada@example.com"],
  "subject": "Refund for order 1041",
  "html": "<p>Refund issued for order 1041.</p>",
  "text": "Refund issued for order 1041."
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts create \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --to ada@example.com \
  --subject "Refund for order 1041" \
  --html "<p>Refund issued for order 1041.</p>" \
  --text "Refund issued for order 1041."
```

To create a reply draft, pass `thread_id` and `reply_to_email_id` together. If you leave out `to`, it is set to the `Reply-To` address of the email you are replying to, or to its sender when it has no `Reply-To`. If the inbox sent that email, `to` is set to that email's recipients instead. `cc` and `bcc` are never filled in. If you leave out `subject`, the draft is sent with the subject of the thread, prefixed with `Re:`.

An email can have only one unsent reply draft. Creating a second one returns the existing draft, and only its attachments are updated.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.create({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  replyToEmailId: '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60',
  subject: 'Re: Refund for order 1041',
  text: 'Refund issued for order 1041.',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->create('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'thread_id' => '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  'reply_to_email_id' => '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60',
  'subject' => 'Re: Refund for order 1041',
  'text' => 'Refund issued for order 1041.',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Drafts.CreateParams = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "reply_to_email_id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  "subject": "Re: Refund for order 1041",
  "text": "Refund issued for order 1041.",
}

resend.Inboxes.Drafts.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "reply_to_email_id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  "subject": "Re: Refund for order 1041",
  "text": "Refund issued for order 1041.",
}

Resend::Inboxes::Drafts.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateInboxDraftRequest{
		ThreadId:       "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		ReplyToEmailId: "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
		Subject:        "Re: Refund for order 1041",
		Text:           "Refund issued for order 1041.",
	}

	client.Inboxes.Drafts.Create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateInboxDraftOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let draft = CreateInboxDraftOptions::reply(
    "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  )
  .with_subject("Re: Refund for order 1041")
  .with_text("Refund issued for order 1041.");

  let _draft = resend
    .inboxes
    .create_draft("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", draft)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.CreateInboxDraftOptions;
import com.resend.services.inboxes.model.CreateInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateInboxDraftOptions params = CreateInboxDraftOptions.builder()
                .threadId("4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12")
                .replyToEmailId("5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60")
                .subject("Re: Refund for order 1041")
                .text("Refund issued for order 1041.")
                .build();

        CreateInboxDraftResponseSuccess data = resend.inboxes().drafts().create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxDraftCreateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxDraftCreateData()
    {
        ThreadId = new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
        ReplyToEmailId = new Guid( "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60" ),
        Subject = "Re: Refund for order 1041",
        TextBody = "Refund issued for order 1041.",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "reply_to_email_id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  "subject": "Re: Refund for order 1041",
  "text": "Refund issued for order 1041."
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts create \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --thread-id 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 \
  --reply-to-email-id 5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60 \
  --subject "Re: Refund for order 1041" \
  --text "Refund issued for order 1041."
```

## Attachments

In the composer, click **Attach files** or drag files onto the message. Attachment content can total up to 25 MB per draft. Images dropped into the body of the message are inserted inline.

Via the API, pass files in the `attachments` array with `content` as a buffer or Base64 encoded string, a `filename` and a `content_type`. You can also pass a `path` URL instead of `content`. The file is downloaded when the request is made and stored on the draft.

## Write with AI

Type <kbd>/</kbd> in the body of a message and choose **Start from a prompt...** to have AI write the message for you. Describe what you want to say, and the message is written in the tone of voice set for the [inbox agent](/docs/guides/inboxes/agent), using the rest of the thread as context. Once there is content in the message you can prompt again to change it.

## View drafts

Select the **Drafts** folder in an inbox to see all of its unsent drafts. Select a draft to continue editing it.

You can also [list drafts](/docs/api-reference/inboxes/list-drafts) via the API, SDKs, or CLI. Drafts are returned most recently updated first.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.list({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->list('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Drafts.list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes::Drafts.list({ "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" })
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Drafts.List("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", nil)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _drafts = resend
    .inboxes
    .list_drafts("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", ListOptions::default())
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ListInboxDraftsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListInboxDraftsResponseSuccess data = resend.inboxes().drafts().list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxDraftListAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
Console.WriteLine( "Nr Drafts={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts list --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1
```

## Update a draft

In the Dashboard, open the draft and edit it. Changes are saved automatically.

You can also [update a draft](/docs/api-reference/inboxes/update-draft) via the API, SDKs, or CLI. Fields you leave out stay as they are, except for `html` and `text`: sending either one replaces both.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.update({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  draftId: 'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32',
  subject: 'Refund issued for order 1041',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->update(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32',
  [
    'subject' => 'Refund issued for order 1041',
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Drafts.UpdateParams = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
  "subject": "Refund issued for order 1041",
}

resend.Inboxes.Drafts.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "draft_id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
  "subject": "Refund issued for order 1041",
}

Resend::Inboxes::Drafts.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	subject := "Refund issued for order 1041"

	params := &resend.UpdateInboxDraftRequest{
		Subject: &subject,
	}

	client.Inboxes.Drafts.Update(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::UpdateInboxDraftOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let update = UpdateInboxDraftOptions::new().with_subject("Refund issued for order 1041");

  let _draft = resend
    .inboxes
    .update_draft(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
      update,
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.UpdateInboxDraftOptions;
import com.resend.services.inboxes.model.UpdateInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxDraftOptions params = UpdateInboxDraftOptions.builder()
                .subject("Refund issued for order 1041")
                .build();

        UpdateInboxDraftResponseSuccess data = resend.inboxes().drafts().update(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxDraftUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32" ),
    new InboxDraftUpdateData()
    {
        Subject = "Refund issued for order 1041",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts/c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "subject": "Refund issued for order 1041"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts update \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --draft-id c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32 \
  --subject "Refund issued for order 1041"
```

## Send a draft

In the Dashboard, click **Send** or press <kbd>⌘</kbd> + <kbd>Enter</kbd>. The email is sent from the inbox address, along with any attachments saved on the draft.

You can also [send a draft](/docs/api-reference/inboxes/send-draft) via the API, SDKs, or CLI. The draft must have at least one recipient in `to` and an `html` or `text` body. A draft that starts a new conversation also needs a `subject`. A reply draft without a subject is sent with the subject of the thread, prefixed with `Re:`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.send({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  draftId: 'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->send(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Drafts.send(
  inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  draft_id="c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "draft_id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
}

Resend::Inboxes::Drafts.send(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Drafts.Send(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
		nil,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::SendInboxDraftOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _email = resend
    .inboxes
    .send_draft(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
      SendInboxDraftOptions::new(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.SendInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        SendInboxDraftResponseSuccess data = resend.inboxes().drafts().send(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxDraftSendAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts/c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32/send' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts send \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --draft-id c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32
```

## Drafts from the inbox agent

If the [inbox agent](/docs/guides/inboxes/agent) is allowed to draft replies or forward threads, it creates drafts for you to review. The agent never sends a draft itself. When you open the thread, the draft appears in the reply composer with a badge showing it was drafted by the agent. Edit it if needed, then send it.

## Discard a draft

In the composer, click the trash icon to discard the draft. In the **Drafts** folder, hover over a draft and click **Discard draft**, or select several drafts and click **Discard**. Each discard shows a notification with an **Undo** button.

You can also [delete a draft](/docs/api-reference/inboxes/delete-draft) via the API, SDKs, or CLI.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.drafts.remove({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  draftId: 'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->drafts->remove(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  'c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Drafts.remove(
  inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  draft_id="c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "draft_id": "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
}

Resend::Inboxes::Drafts.remove(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Drafts.Remove(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .inboxes
    .delete_draft(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.RemoveInboxDraftResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveInboxDraftResponseSuccess data = resend.inboxes().drafts().remove(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxDraftDeleteAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/drafts/c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes drafts delete \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --draft-id c3a1e8b4-2d5f-4a7c-9e10-6b8d7f5a4c32 \
  --yes
```

## API Reference

For complete API documentation, see the [Inbox Drafts API reference](/docs/api-reference/inboxes/create-draft).


# Manage Labels
Source: https://resend.com/docs/guides/inboxes/labels

Learn how to organize threads with inbox labels.

A label is a named, colored tag that you can apply to threads to keep an inbox organized. Labels belong to a single inbox, and a thread can have more than one label.

## Create a label

### Using the dashboard

**1. Open an inbox and click the **Settings** button.**

**2. Select the **Labels** tab.**

**3. Click **Add label**.**

**4. Enter a name for the label and choose a color.**

New labels start with a random color.

**5. Save the label.**

Press <kbd>Enter</kbd> or click the check button.

You can also create a label while applying it to a thread. Type the new name into the **Label as** menu and choose **Create label**.

An inbox can have up to 100 labels, and each label name must be unique within the inbox, ignoring case.

### Using the API

The color is a `#RRGGBB` hex code. If you leave it out, Resend picks one for you.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.labels.create({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  name: 'Urgent',
  color: '#E93D82',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->labels->create('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'name' => 'Urgent',
  'color' => '#E93D82',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Labels.CreateParams = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "name": "Urgent",
  "color": "#E93D82",
}

resend.Inboxes.Labels.create(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "name": "Urgent",
  "color": "#E93D82",
}

Resend::Inboxes::Labels.create(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.CreateInboxLabelRequest{
		Name:  "Urgent",
		Color: "#E93D82",
	}

	client.Inboxes.Labels.Create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::CreateInboxLabelOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let label = CreateInboxLabelOptions::new("Urgent").with_color("#E93D82");

  let _label = resend
    .inboxes
    .create_label("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", label)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.CreateInboxLabelOptions;
import com.resend.services.inboxes.model.CreateInboxLabelResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateInboxLabelOptions params = CreateInboxLabelOptions.builder()
                .name("Urgent")
                .color("#E93D82")
                .build();

        CreateInboxLabelResponseSuccess data = resend.inboxes().labels().create("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxLabelCreateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxLabelCreateData()
    {
        Name = "Urgent",
        Color = "#E93D82",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/labels' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Urgent",
  "color": "#E93D82"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes labels create \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --name Urgent \
  --color '#E93D82'
```

## Apply labels to threads

In the Dashboard, open a thread or hover over it in the thread list and click **Label as**, or press <kbd>L</kbd>. Check the labels you want to apply and uncheck the ones you want to remove. To label many threads at once, select them in the list and use **Label as** in the bar at the bottom of the list.

You can also remove a label from a thread by clicking the **×** on the label under the thread subject.

> [!TIP]
>
> **Move to**, or <kbd>V</kbd>, lists your labels alongside your folders.
> Choosing a label from **Move to** applies the label and archives the thread in
> one step, which is useful for clearing your inbox.

You can also change a thread's labels via the API, SDKs, or CLI:

* [Add thread labels](/docs/api-reference/inboxes/add-thread-labels) applies up to 10 labels and keeps the labels already on the thread.
* [Set thread labels](/docs/api-reference/inboxes/set-thread-labels) replaces every label on the thread. Pass an empty list to remove them all.
* [Remove thread label](/docs/api-reference/inboxes/remove-thread-label) removes a single label from the thread.

Removing a label from a thread does not delete the label.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.labels.add({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  labels: ['7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34'],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->labels->add(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  [
    'labels' => ['7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34'],
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.Labels.AddParams = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "labels": ["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"],
}

resend.Inboxes.Threads.Labels.add(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "labels": ["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"],
}

Resend::Inboxes::Threads::Labels.add(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.AddInboxThreadLabelsRequest{
		Labels: []string{"7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"},
	}

	client.Inboxes.Threads.Labels.Add(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _labels = resend
    .inboxes
    .add_thread_labels(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      &["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"],
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.AddInboxThreadLabelsOptions;
import com.resend.services.inboxes.model.AddInboxThreadLabelsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        AddInboxThreadLabelsOptions params = AddInboxThreadLabelsOptions.builder()
                .labels("7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34")
                .build();

        AddInboxThreadLabelsResponseSuccess data = resend.inboxes().threads().addLabels(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxThreadLabelAddAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    new List<Guid> { new Guid( "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34" ) }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/labels' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "labels": ["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"]
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads labels add \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --thread-id 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 \
  --labels 7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34
```

The [inbox agent](/docs/guides/inboxes/agent) can also apply your existing labels to threads based on your instructions.

## Filter threads by label

In the Dashboard, select a label in the left rail or from the folder switcher to see only the threads with that label. You can also click a label on a thread, or use the `label:` operator in search.

Labels also power the **Grouped list** and card-based [inbox views](/docs/guides/inboxes/manage-inboxes#edit-an-inbox), which group threads by label.

To filter threads by label via the API, pass a comma-separated list of label IDs in the `labels` parameter when you [list](/docs/api-reference/inboxes/list-threads) or [search](/docs/api-reference/inboxes/search-threads) threads.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.list({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  labels: ['7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34'],
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->list('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'labels' => ['7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34'],
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.ListParams = {
  "labels": ["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"],
}

resend.Inboxes.Threads.list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "labels": ["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"],
}

Resend::Inboxes::Threads.list(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.ListInboxThreadsOptions{
		Labels: []string{"7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"},
	}

	client.Inboxes.Threads.List("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, types::ListInboxThreadsOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let filters = ListInboxThreadsOptions::new().with_labels(["7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34"]);

  let _threads = resend
    .inboxes
    .list_threads(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      filters,
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ListInboxThreadsParams;
import com.resend.services.inboxes.model.ListInboxThreadsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListInboxThreadsParams params = ListInboxThreadsParams.builder()
                .labels("7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34")
                .build();

        ListInboxThreadsResponseSuccess data = resend.inboxes().threads().list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadListAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxThreadListQuery()
    {
        Labels = new List<Guid> { new Guid( "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34" ) },
    }
);
Console.WriteLine( "Nr Threads={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads?labels=7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads list \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --labels 7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34
```

When you filter by label, threads in the `inbox`, `archive`, and `sent` folders are included by default.

## Edit a label

In the **Labels** tab of the inbox settings, click a label to change its name or color, then press <kbd>Enter</kbd> or click the check button.

You can also [update a label](/docs/api-reference/inboxes/update-label) via the API, SDKs, or CLI.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.labels.update({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  labelId: '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34',
  name: 'Priority',
  color: '#F76B15',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->labels->update(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34',
  [
    'name' => 'Priority',
    'color' => '#F76B15',
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Labels.UpdateParams = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
  "name": "Priority",
  "color": "#F76B15",
}

resend.Inboxes.Labels.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "label_id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
  "name": "Priority",
  "color": "#F76B15",
}

Resend::Inboxes::Labels.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.UpdateInboxLabelRequest{
		Name:  "Priority",
		Color: "#F76B15",
	}

	client.Inboxes.Labels.Update(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::UpdateInboxLabelOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let update = UpdateInboxLabelOptions::new()
    .with_name("Priority")
    .with_color("#F76B15");

  let _label = resend
    .inboxes
    .update_label(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
      update,
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.UpdateInboxLabelOptions;
import com.resend.services.inboxes.model.UpdateInboxLabelResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxLabelOptions params = UpdateInboxLabelOptions.builder()
                .name("Priority")
                .color("#F76B15")
                .build();

        UpdateInboxLabelResponseSuccess data = resend.inboxes().labels().update(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxLabelUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34" ),
    new InboxLabelUpdateData()
    {
        Name = "Priority",
        Color = "#F76B15",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/labels/7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Priority",
  "color": "#F76B15"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes labels update \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --label-id 7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34 \
  --name Priority \
  --color '#F76B15'
```

## Delete a label

In the **Labels** tab of the inbox settings, click the trash icon next to the label. If the label is applied to any threads, you will be asked to confirm that you want to remove it from those threads.

Deleting a label removes it from every thread it was applied to. The threads themselves are not affected and stay in their current folders.

You can also [delete a label](/docs/api-reference/inboxes/delete-label) via the API, SDKs, or CLI.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.labels.remove({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  labelId: '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->labels->remove(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Labels.remove(
  inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  label_id="7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "label_id": "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
}

Resend::Inboxes::Labels.remove(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Labels.Remove(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .inboxes
    .delete_label(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.RemoveInboxLabelResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveInboxLabelResponseSuccess data = resend.inboxes().labels().remove(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxLabelDeleteAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/labels/7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes labels delete \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --label-id 7f9c1d2e-4a6b-4c3d-8e15-9b0a7c6d5e34 \
  --yes
```

## API Reference

For complete API documentation, see the [Inbox Labels API reference](/docs/api-reference/inboxes/create-label).


# Managing Inboxes
Source: https://resend.com/docs/guides/inboxes/manage-inboxes

Learn how to rename, update and delete inboxes in Resend.

Once you have created an inbox, all members of your team can view the inbox, update it and delete it once it is no longer required.

## View an inbox

See the address, unread count, and the date of the last received email on the [Inboxes dashboard](https://resend.com/inboxes). You can also search for inboxes by name.

Select any individual inbox to view its threads and to make changes to it.

## Edit an inbox

While viewing an inbox, click on the **Settings** button to reconfigure your inbox.

The General settings allow you to change the inbox nickname, which is the name that you see within the Dashboard. You can also change the **Reply as** name, which is the name that people who receive emails from this inbox will see. This is the `from_name` field in the API.

You can also [update an inbox](/docs/api-reference/inboxes/update-inbox) via the API, SDKs, or CLI.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.update(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  { name: 'Customer Support', fromName: 'Ada from Support' },
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->update('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'name' => 'Customer Support',
  'from_name' => 'Ada from Support',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.UpdateParams = {
  "id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "name": "Customer Support",
  "from_name": "Ada from Support",
}

resend.Inboxes.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "name": "Customer Support",
  "from_name": "Ada from Support",
}

Resend::Inboxes.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	fromName := "Ada from Support"

	params := &resend.UpdateInboxRequest{
		Name:     "Customer Support",
		FromName: &fromName,
	}

	client.Inboxes.Update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::UpdateInboxOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let update = UpdateInboxOptions::new()
    .with_name("Customer Support")
    .with_from_name("Ada from Support");

  let _inbox = resend
    .inboxes
    .update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", update)
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.UpdateInboxOptions;
import com.resend.services.inboxes.model.UpdateInboxResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxOptions params = UpdateInboxOptions.builder()
                .name("Customer Support")
                .fromName("Ada from Support")
                .build();

        UpdateInboxResponseSuccess data = resend.inboxes().update("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxUpdateData()
    {
        Name = "Customer Support",
        FromName = "Ada from Support",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "name": "Customer Support",
  "from_name": "Ada from Support"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes update b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --name "Customer Support" \
  --from-name "Ada from Support"
```

In the Dashboard, you can also update how you view threads in the inbox. You can choose from **Simple list** (the default), **Grouped list**, **Board**, **Swimlanes**, or **Cards and list**. Grouped and card views group threads by label. These view options are not available through the API.

![Choose an inbox view: Simple list, Grouped list, Board, Swimlanes, or Cards and list](https://mintcdn.com/resend/2wyYbavX_c3s0W4P/images/inbox-view.png?fit=max\&auto=format\&n=2wyYbavX_c3s0W4P\&q=85\&s=23b53f0365280fd5137099dd006c3667)

## Inbox agent

In the settings menu, under **Customize**, is the configuration for the built-in agent for this inbox. Each inbox has an agent that can take instructions, perform actions and draft responses. You can find more details about this agent in [Inbox Agent](/docs/guides/inboxes/agent).

## Inbox labels

In the settings menu, under **Labels**, you can add, edit and remove labels that can be used to organize threads. Find more details about how to use labels under [Inbox Labels](/docs/guides/inboxes/labels).

## Delete an inbox

In the Dashboard, you can delete an inbox either from the settings panel at the bottom of the general settings, or from the [list of inboxes](https://resend.com/inboxes). To delete an inbox:

**1. Click **Delete inbox****

**2. Enter the email address into the form to confirm**

**3. Delete the inbox**

You can also [delete an inbox](/docs/api-reference/inboxes/delete-inbox) via the API, SDKs, or CLI.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.remove(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
);
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->remove('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.remove("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes.remove("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Remove("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .inboxes
    .delete("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.RemoveInboxResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveInboxResponseSuccess data = resend.inboxes().remove("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxDeleteAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes delete b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 --yes
```

Deleting an inbox *cannot be undone* and severs the connection between the emails that were sent and received by an inbox.

Deleting an inbox removes its threads and the emails in them from the inbox. The individual emails can still be viewed in the [Emails dashboard](https://resend.com/emails). If your domain is configured to receive emails and trigger `email.received` webhooks, they will continue to fire too.

## API Reference

For complete API documentation, see the [Inboxes API reference](/docs/api-reference/inboxes/update-inbox).


# Managing Threads
Source: https://resend.com/docs/guides/inboxes/threads

Learn how to read, organize, search, and respond to threads.

A thread is a conversation within an inbox. Emails sent and received in reply to each other are grouped into the same thread, so you can read, organize and respond to the whole conversation in one place.

## Folders

* `inbox`: The default. The thread holds at least one received message.
* `archive`: The thread was archived.
* `spam`: The thread was marked as spam.
* `trash`: The thread is scheduled for deletion in 30 days.
* `sent`: Threads whose messages are all outbound.

In the Dashboard, the folder switcher also shows a **Drafts** folder that lists your unsent [drafts](/docs/guides/inboxes/drafts). The **Inbox** folder shows a count of unread threads.

## View threads

Select an inbox from the [Inboxes dashboard](https://resend.com/inboxes) to see its threads, most recently active first. Use the folder switcher to change folders, or select a label in the left rail to see only the threads with that [label](/docs/guides/inboxes/labels).

Select a thread to open it and read every email in the conversation. Opening a thread marks it as read. Use the **Next email** and **Previous email** buttons, or the <kbd>↓</kbd> and <kbd>↑</kbd> keys, to move between threads.

You can also [list threads](/docs/api-reference/inboxes/list-threads) via the API, SDKs, or CLI, filtered by folder, label and read status.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.list({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->list('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1');
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Threads.list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1")
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

Resend::Inboxes::Threads.list({ "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" })
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Threads.List("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", nil)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, types::ListInboxThreadsOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _threads = resend
    .inboxes
    .list_threads(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      ListInboxThreadsOptions::new(),
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ListInboxThreadsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListInboxThreadsResponseSuccess data = resend.inboxes().threads().list("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadListAsync( new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ) );
Console.WriteLine( "Nr Threads={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads list --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1
```

To read the emails in a thread, [list the thread emails](/docs/api-reference/inboxes/list-thread-emails). They are returned oldest first.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.emails.list({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->emails->list(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Threads.Emails.list(
  inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id="4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
}

Resend::Inboxes::Threads::Emails.list(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Threads.Emails.List(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		nil,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _emails = resend
    .inboxes
    .list_thread_emails(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ListInboxThreadEmailsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ListInboxThreadEmailsResponseSuccess data = resend.inboxes().threads().emails().list(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadEmailListAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" )
);
Console.WriteLine( "Nr Emails={0}", resp.Content.Data.Count );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X GET 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads emails list \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --thread-id 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12
```

## Search threads

In the Dashboard, click the search icon or press <kbd>/</kbd> to search the inbox. Quick filters let you narrow results to emails **From me**, **Unread**, **Has attachments** or **Assigned to me**. You can also type search operators such as `from:`, `to:`, `label:`, `has:`, `is:`, `after:` and `before:`. Dates use the `YYYY-MM-DD` format.

You can also [search threads](/docs/api-reference/inboxes/search-threads) via the API, SDKs, or CLI by text, sender, recipient, attachments and date.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.search({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  query: 'invoice -draft',
  from: ['isabella@example.com', 'carolina@example.com'],
  startDate: '2026-09-01',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->search('b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1', [
  'query' => 'invoice -draft',
  'from' => ['isabella@example.com', 'carolina@example.com'],
  'start_date' => '2026-09-01',
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.SearchParams = {
  "query": "invoice -draft",
  "from": ["isabella@example.com", "carolina@example.com"],
  "start_date": "2026-09-01",
}

resend.Inboxes.Threads.search("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "query": "invoice -draft",
  "from": ["isabella@example.com", "carolina@example.com"],
  "start_date": "2026-09-01",
}

Resend::Inboxes::Threads.search(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.SearchInboxThreadsOptions{
		Query:     "invoice -draft",
		From:      []string{"isabella@example.com", "carolina@example.com"},
		StartDate: "2026-09-01",
	}

	client.Inboxes.Threads.Search("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{list_opts::ListOptions, types::SearchInboxThreadsOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let search = SearchInboxThreadsOptions::new()
    .with_query("invoice -draft")
    .with_from(["isabella@example.com", "carolina@example.com"])
    .with_start_date("2026-09-01");

  let _results = resend
    .inboxes
    .search_threads(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      search,
      ListOptions::default(),
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.SearchInboxThreadsParams;
import com.resend.services.inboxes.model.SearchInboxThreadsResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        SearchInboxThreadsParams params = SearchInboxThreadsParams.builder()
                .query("invoice -draft")
                .from("isabella@example.com", "carolina@example.com")
                .startDate("2026-09-01")
                .build();

        SearchInboxThreadsResponseSuccess data = resend.inboxes().threads().search("b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1", params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.InboxThreadSearchAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new InboxThreadSearchQuery()
    {
        Query = "invoice -draft",
        From = new List<string> { "isabella@example.com", "carolina@example.com" },
        StartDate = "2026-09-01",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl --get 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/search' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     --data-urlencode 'query=invoice -draft' \
     --data-urlencode 'from=isabella@example.com,carolina@example.com' \
     --data-urlencode 'start_date=2026-09-01'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads search \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --query "invoice -draft" \
  --from isabella@example.com carolina@example.com \
  --start-date 2026-09-01
```

> [!NOTE]
>
> Search can be up to about a minute behind new emails. To browse an inbox
> exactly as it is right now, list threads instead.

## Organize threads

You can act on a thread from the thread view, from the actions that appear when you hover over a thread in the list, or on many threads at once by selecting them and using the actions in the bar at the bottom of the list.

* **Mark as read** or **Mark as unread** changes the read status of every email in the thread.
* **Archive** moves the thread to the archive folder.
* **Report spam** moves the thread to the spam folder. From the spam folder, use **Report not spam** to move it back.
* **Delete** moves the thread to the trash. Threads in the trash are scheduled for deletion in 30 days.
* **Move to** moves the thread to another folder, or applies a [label](/docs/guides/inboxes/labels), and archives the thread.
* **Label as** adds or removes [labels](/docs/guides/inboxes/labels).

Each move shows a notification with an **Undo** button. To restore a thread from the archive, spam or trash, use **Move to** and choose **Inbox**.

You can also [update a thread](/docs/api-reference/inboxes/update-thread) via the API, SDKs, or CLI to mark it as read or unread, or move it to the `inbox`, `archive`, `spam` or `trash` folder.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.update({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  read: true,
  folder: 'archive',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->update(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  [
    'read' => true,
    'folder' => 'archive',
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.UpdateParams = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "read": True,
  "folder": "archive",
}

resend.Inboxes.Threads.update(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "read": true,
  "folder": "archive",
}

Resend::Inboxes::Threads.update(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	read := true
	params := &resend.UpdateInboxThreadRequest{
		Read:   &read,
		Folder: resend.InboxMoveThreadFolderArchive,
	}

	client.Inboxes.Threads.Update(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::{UpdateInboxThreadFolder, UpdateInboxThreadOptions}, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let update = UpdateInboxThreadOptions::new()
    .with_read(true)
    .with_folder(UpdateInboxThreadFolder::Archive);

  let _thread = resend
    .inboxes
    .update_thread(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      update,
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.MoveInboxThreadFolder;
import com.resend.services.inboxes.model.UpdateInboxThreadOptions;
import com.resend.services.inboxes.model.UpdateInboxThreadResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        UpdateInboxThreadOptions params = UpdateInboxThreadOptions.builder()
                .read(true)
                .folder(MoveInboxThreadFolder.ARCHIVE)
                .build();

        UpdateInboxThreadResponseSuccess data = resend.inboxes().threads().update(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxThreadUpdateAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    new InboxThreadUpdateData()
    {
        IsRead = true,
        Folder = InboxMoveFolder.Archive,
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X PATCH 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "read": true,
  "folder": "archive"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads update \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --thread-id 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 \
  --read \
  --folder archive
```

## Delete a thread

Deleting a thread moves it to the trash and schedules it for deletion in 30 days. Until then, you can restore it by moving it back to another folder.

You can also [delete a thread](/docs/api-reference/inboxes/delete-thread) via the API, SDKs, or CLI.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.remove({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->remove(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12'
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

resend.Inboxes.Threads.remove(
  inbox_id="b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  thread_id="4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
}

Resend::Inboxes::Threads.remove(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	client.Inboxes.Threads.Remove(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let _deleted = resend
    .inboxes
    .delete_thread(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.RemoveInboxThreadResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        RemoveInboxThreadResponseSuccess data = resend.inboxes().threads().remove(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12");
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxThreadDeleteAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" )
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X DELETE 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12' \
     -H 'Authorization: Bearer re_xxxxxxxxx'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads delete \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --thread-id 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 \
  --yes
```

## Assign a thread

In the Dashboard, you can assign a thread to a member of your team so everyone knows who is handling it. Hover over a thread in the list and click **Assign thread**, or press <kbd>A</kbd>, then search for a teammate. Choose **Unassigned** to remove the assignment.

The [inbox agent](/docs/guides/inboxes/agent) can also assign threads based on your instructions.

## Reply and forward

While viewing a thread, use the **Reply**, **Reply all** or **Forward** buttons at the bottom of the thread, or the **More** menu on an individual email. The reply opens inline beneath the email and is saved as a [draft](/docs/guides/inboxes/drafts) as you write. Click **Send** or press <kbd>⌘</kbd> + <kbd>Enter</kbd> to send it.

Replies are sent from the inbox address and are threaded for the recipient. You can also [reply to](/docs/api-reference/inboxes/reply-thread-email) or [forward](/docs/api-reference/inboxes/forward-thread-email) an email via the API, SDKs, or CLI.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

const { data, error } = await resend.inboxes.threads.emails.reply({
  inboxId: 'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  threadId: '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  emailId: '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60',
  text: 'Refund issued for order 1041.',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->inboxes->threads->emails->reply(
  'b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1',
  '4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12',
  '5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60',
  [
    'text' => 'Refund issued for order 1041.',
  ]
);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Inboxes.Threads.Emails.ReplyParams = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "email_id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  "text": "Refund issued for order 1041.",
}

resend.Inboxes.Threads.Emails.reply(params)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
  "thread_id": "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
  "email_id": "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
  "text": "Refund issued for order 1041.",
}

Resend::Inboxes::Threads::Emails.reply(params)
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import "github.com/resend/resend-go/v4"

func main() {
	client := resend.NewClient("re_xxxxxxxxx")

	params := &resend.ReplyInboxThreadEmailRequest{
		Text: "Refund issued for order 1041.",
	}

	client.Inboxes.Threads.Emails.Reply(
		"b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
		"4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
		"5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
		params,
	)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::{types::ReplyInboxThreadEmailOptions, Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let reply = ReplyInboxThreadEmailOptions::new().with_text("Refund issued for order 1041.");

  let _email = resend
    .inboxes
    .reply_thread_email(
      "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
      "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
      reply,
    )
    .await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.inboxes.model.ReplyInboxThreadEmailOptions;
import com.resend.services.inboxes.model.ReplyInboxThreadEmailResponseSuccess;

public class Main {
    public static void main(String[] args) throws ResendException {
        Resend resend = new Resend("re_xxxxxxxxx");

        ReplyInboxThreadEmailOptions params = ReplyInboxThreadEmailOptions.builder()
                .text("Refund issued for order 1041.")
                .build();

        ReplyInboxThreadEmailResponseSuccess data = resend.inboxes().threads().emails().reply(
                "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
                "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12",
                "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60",
                params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

await resend.InboxThreadEmailReplyAsync(
    new Guid( "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1" ),
    new Guid( "4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12" ),
    new Guid( "5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60" ),
    new InboxThreadEmailReplyData()
    {
        TextBody = "Refund issued for order 1041.",
    }
);
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/inboxes/b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1/threads/4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12/emails/5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60/reply' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "text": "Refund issued for order 1041."
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend inboxes threads emails reply \
  --inbox-id b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1 \
  --thread-id 4d8e2a1c-9b3f-4c6d-8a21-3e5f7c9c0d12 \
  --email-id 5b1a9f47-2c8d-4e6f-9a03-1d2e3f4a5b60 \
  --text "Refund issued for order 1041."
```

## Keyboard shortcuts

Press <kbd>?</kbd> in the Dashboard to see every keyboard shortcut. The most useful are:

| Shortcut | Action |
| - | - |
| <kbd>/</kbd> | Search emails |
| <kbd>C</kbd> | Compose |
| <kbd>↓</kbd> / <kbd>↑</kbd> | Next or previous email |
| <kbd>X</kbd> | Select email |
| <kbd>E</kbd> | Archive |
| <kbd>⇧</kbd> + <kbd>U</kbd> | Toggle read |
| <kbd>A</kbd> | Assign to |
| <kbd>L</kbd> | Label as |
| <kbd>V</kbd> | Move to |
| <kbd>!</kbd> | Report spam or not spam |
| <kbd>Backspace</kbd> | Move to trash |
| <kbd>Esc</kbd> | Go back or close composer |

## API Reference

For complete API documentation, see the [Inbox Threads API reference](/docs/api-reference/inboxes/list-threads).


# Laravel Cloud Integration
Source: https://resend.com/docs/guides/laravel-cloud-integration

Connect a Resend account to Laravel Cloud and send email from your environments.

[Laravel Cloud](https://laravel.com/cloud) hosts Laravel applications and manages Resend as an email resource. Connect a Resend account once for your organization, then attach email to any environment. Laravel Cloud creates a sending key and injects the mail variables your application needs.

## What you get

* OAuth connection to your Laravel Cloud organization.
* Resource you can reuse across environments.
* A sending key for each environment, injected as environment variables.
* Billing that stays on your [Resend plan](/docs/dashboard/settings/billing).

## Prerequisites

* A Laravel Cloud organization with an environment.
* A Resend account with a [verified domain](/docs/add-a-domain).

## Connect your Resend account

Connect from the organization settings, or the first time you attach email to an environment. Either path sends you to Resend to approve access.

Prefer a video walkthrough?

[YouTube video player](https://www.youtube.com/embed/6UTw4x4VG_Q)

**1. Open the canvas**

Open the environment canvas and choose the **Email** resource.

**2. Approve full access**

On the Resend consent screen, pick the team Laravel Cloud should use and choose **Full access**. Laravel Cloud returns you to the same environment and imports the sending domains already on that team.

> [!NOTE]
>
> **Full access** lets Laravel Cloud import your existing domains and set up the
> webhooks it needs. **Sending access** can only send email, so Laravel Cloud
> can't finish setup with that permission.

<video aria-label="Connecting a Resend account from the Laravel Cloud canvas" />

**3. Connect a domain and create a key**

Select a verified domain or create a new one. Click **Continue**.

<video aria-label="Choosing a sending domain, sender, and key, then attaching email to a Laravel Cloud environment" />

Enter the sender address and sender name, then choose a sending key.

* **Create a new key** creates a full access key used by this environment.
* **Reuse existing key** shares a key already used by another environment in the organization.

Confirm and attach email to finish.

**4. Redeploy your application**

For changes to take effect, redeploy your application.

Connecting and disconnecting requires the **Edit organization integrations** permission. See [roles and permissions](https://laravel.com/cloud/docs/rbac) for more details.

### Injected environment variables

```ini theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY=re_xxxxxxxxxxxx
MAIL_MAILER=resend
MAIL_FROM_ADDRESS=hello@notifications.example.com
MAIL_FROM_NAME="Your application name"
```

`MAIL_FROM_ADDRESS` and `MAIL_FROM_NAME` use the sender you entered. Laravel Cloud encrypts `RESEND_API_KEY` and masks it, the same way it handles a database password.

A custom environment variable with the same name takes priority over an injected one. Define the custom variable, then deploy. See [Laravel Cloud's environment variables documentation](https://laravel.com/cloud/docs/environments#environment-variables) for how overrides work.

To send from your own machine, copy these variables into your local `.env`. Laravel Cloud injects them into the hosted environment.

## Send from your application

### Laravel

[Laravel ships with a Resend mail transport](https://laravel.com/cloud/docs/resources/email#laravel). The transport needs Resend's PHP SDK. If the package is missing, Laravel Cloud prompts you to add it to the project's dependencies:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
composer require resend/resend-php
```

Laravel reads the injected variables directly, so no further configuration is required. Send mail as you normally would:

```php theme={"theme":{"light":"github-light","dark":"vesper"}}
use Illuminate\Support\Facades\Mail;

Mail::to($user)->send(new OrderShipped($order));
```

The key has full access, so the same application can call the rest of the Resend API. Install [`resend/resend-laravel`](/docs/send-with-laravel) for the Laravel SDK, or send over [SMTP](/docs/send-with-laravel-smtp).

### Other frameworks

Laravel Cloud injects `RESEND_API_KEY` for every runtime. Read the key from the environment and pass it to the [API](/docs/api-reference/introduction) or an [SDK](/docs/sdks).

> [!NOTE]
>
> Queued mail can fail as a failed job. [Laravel
> Nightwatch](https://nightwatch.laravel.com) traces those jobs and alerts you
> when they start failing.

## Attach Resend with the API

[Attach Resend to an environment](https://laravel.com/cloud/docs/api/email/attach-resend-to-environment#attach-resend-to-environment) with a bearer token from the Laravel Cloud UI. `from_address` and `from_name` are required. Set `key_strategy` to `create` for a new key, or `reuse` and pass `reuse_key_id` to share a key another environment already uses. `key_name` is optional.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
curl --request POST \
  --url https://cloud.laravel.com/api/environments/{environment}/resend \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "from_address": "hello@notifications.example.com",
  "from_name": "Acme",
  "key_name": "production",
  "key_strategy": "create"
}'
```

Deploy the environment after the request so the application receives the mail variables.

The same API can list what you attach and change it later:

* [List sending domains](https://laravel.com/cloud/docs/api/email/list-sending-domains) for the organization.
* [List reusable sending keys](https://laravel.com/cloud/docs/api/email/list-reusable-sending-keys) that other environments can share.
* [Update the sender](https://laravel.com/cloud/docs/api/email/update-environment-resend-sender) with `from_address` and `from_name`.
* [Detach Resend](https://laravel.com/cloud/docs/api/email/detach-resend-from-environment). This deletes the environment's sending key unless another environment shares it.

## Next steps

* Send your first email with [Laravel](/docs/send-with-laravel).
* Add and verify a [domain](/docs/dashboard/domains/introduction).
* Design messages with [Templates](/docs/dashboard/templates/introduction).
* Follow up with an [Automation](/docs/dashboard/automations/introduction).


# Turn Paper designs into Resend emails
Source: https://resend.com/docs/guides/paper

Learn how to combine the Paper MCP server and the Resend MCP server so your agent can turn a Paper design into a template or broadcast in your Resend account.

[Paper](https://paper.design) is a design tool built for AI agents. Its MCP server lets agents read your canvas, including layout, styles, copy, and screenshots. Combined with the [Resend MCP server](/docs/mcp-server), your agent can take a design straight from Paper and turn it into a ready-to-send [Template](/docs/dashboard/templates/introduction) or [Broadcast](/docs/dashboard/broadcasts/introduction) in your Resend account.

The flow looks like this:

1. You design an email in Paper.
2. Your agent reads the design through the Paper MCP server.
3. Your agent converts the design into email-safe HTML using the [Resend MCP server](/docs/mcp-server) and [agent skills](/docs/resend-skill).
4. Your agent creates a Template or Broadcast in Resend

## Prerequisites

Before you start, make sure you have:

* The [Paper Desktop app](https://paper.design/downloads) installed with a file open (opening a file starts the Paper MCP server automatically)
* A [Resend account](https://resend.com/signup) with a [verified domain](/docs/add-a-domain)
* An MCP client like Claude Code, Cursor, or Claude Desktop

> [!NOTE]
>
> [See a full example](#example-end-to-end-prompt) for a complete end-to-end
> prompt.

## Guide

**1. Connect the Paper MCP server**

Paper Desktop runs a local MCP server at `http://127.0.0.1:29979/mcp` whenever a file is open.

> [tab] Claude Code
>
> Install the official Paper plugin (recommended):
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> /plugin marketplace add paper-design/agent-plugins
> /plugin install paper-desktop@paper
> ```
>
> Or add the MCP server directly:
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> claude mcp add paper --transport http http://127.0.0.1:29979/mcp --scope user
> ```

> [tab] Codex
>
> Install the official Paper plugin (recommended):
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> codex plugin marketplace add paper-design/agent-plugins
> /plugins
> ```
>
> Select the `paper-design/agent-plugins` marketplace and install the `paper-desktop` plugin.

> [tab] Cursor
>
> Run `/add-plugin paper-desktop` in the agent panel, or search for "Paper" in the [Cursor Marketplace](https://cursor.com/marketplace/paper).

> [tab] Claude Desktop
>
> Open Claude Desktop settings > "Developer" tab > "Edit Config".
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "paper": {
>       "command": "npx",
>       "args": ["mcp-remote", "http://127.0.0.1:29979/mcp"]
>     }
>   }
> }
> ```

See the [Paper MCP docs](https://paper.design/docs/mcp) for other clients.

**2. Connect the Resend MCP server**

Connect to Resend's hosted MCP server at `https://mcp.resend.com/mcp`. When you connect, your client opens a browser window to log in to Resend and approve access.

> [tab] Claude Code
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> claude mcp add --transport http resend https://mcp.resend.com/mcp
> ```
>
> Then run `/mcp` in Claude Code and select **resend** to complete the OAuth login.

> [tab] Codex
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> codex mcp add resend --url https://mcp.resend.com/mcp
> ```

> [tab] Cursor
>
> Open the command palette and choose "Cursor Settings" > "MCP" > "Add new global MCP server".
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "url": "https://mcp.resend.com/mcp"
>     }
>   }
> }
> ```

> [tab] Claude Desktop
>
> Open **Settings** > **Connectors** > **Add custom connector** and enter:
>
> ```
> https://mcp.resend.com/mcp
> ```

For more clients and configuration options, including running the server locally, see the [MCP Server overview](/docs/mcp-server).

**3. Design your email in Paper**

Design your email as an artboard in Paper. A few tips for designs that translate well to email:

* Use a single-column layout around 600px wide.
* Use real copy instead of placeholder text.
* Use web-safe fonts like `System Sans-Serif` or `System Serif`.
* Use PNG or JPG images instead of SVGs (not supported in email).

> [!TIP]
>
> Where you want personalization, write the variable directly into the design
> copy. For a template, use `{{{NAME}}}` and have your agent declare `NAME` as
> a variable with a
> [fallback value](/docs/dashboard/templates/template-variables#fallback-values).
> For a Broadcast, use a contact property with an inline fallback, like
> `{{{contact.first_name|there}}}` (see
> [Personalize your content](/docs/dashboard/broadcasts/editor#personalize-your-content)).

**4. Ask your agent to create an email**

You can create either a [Template](/docs/dashboard/templates/introduction) or a [Broadcast](/docs/dashboard/broadcasts/introduction).

To create a template, select an artboard in Paper and with both servers connected, prompt your agent with the following:

```text theme={"theme":{"light":"github-light","dark":"vesper"}}
Look at the selected artboard in Paper and recreate it as an email template
in Resend. Convert the design to email-safe HTML (inline styles, table-based
layout) using the Resend agent skills. Provide a name, subject, and preview text for the template that fits the content. Declare each {{{VARIABLE}}} in
the copy as a template variable with a fallback value. Publish the template.
```

Behind the scenes, the agent will:

1. Call Paper's `get_selection` and `get_screenshot` to see the design.
2. Call Paper's `get_jsx` or `get_computed_styles` to read the exact layout, colors, and copy.
3. Convert the output into email-safe HTML.
4. Call Resend's `create-template` with the HTML, name, and subject.
5. Call Resend's `publish-template` to make it available for sending.

Templates support variables using triple-brace syntax, like `{{{USERNAME}}}`. Once published, you can send the template via the [Emails API](/docs/api-reference/emails/send-email) or the dashboard.

To create a Broadcast and go from design to a campaign instead:

```text theme={"theme":{"light":"github-light","dark":"vesper"}}
Look at the selected artboard in Paper and create a Resend broadcast from it.
Convert the design to email-safe HTML using the Resend agent skills. Provide a name, subject, and preview text for the template that fits the content. Create it as a
draft, don't send it yet.
```

The agent reads the design the same way, then calls Resend's `create-broadcast` with the HTML, sender, subject, and segment. You can review the draft in the [Resend dashboard](https://resend.com/broadcasts) before sending it yourself.

> [!NOTE]
>
> Before you can send a Broadcast, you must define which
> [Segment](/docs/dashboard/segments/introduction) should receive it. If you don't
> have one yet, your agent can create one.

**5. Refine in the visual editor**

Templates and Broadcasts created by your agent are editable in the Resend dashboard. If you want your agent's content to be fully editable in the visual editor, ask it to use `compose-template` or `compose-broadcast` instead of raw HTML. You'll see the agent appear as a named avatar in the editor while it works, and you can hand-tune the result afterwards.

![Hold to confirm](https://mintcdn.com/resend/-o1zsRAiPDVqrcrl/images/paper-hold-to-confirm.png?fit=max\&auto=format\&n=-o1zsRAiPDVqrcrl\&q=85\&s=861731001481ea29e353748aafb5af86)

Alternatively, you can edit the Template or Broadcast in the Resend dashboard. Select the **Editor icon** in the top lefthand corner and **Hold to confirm** and convert the HTML to a visual template or broadcast.

## Example: end-to-end prompt

```text theme={"theme":{"light":"github-light","dark":"vesper"}}
1. Read the "Launch Announcement" artboard from Paper.
2. Convert it to an email-safe HTML email. Preserve the colors, spacing, and
   copy as closely as email clients allow. Use the Resend agent skills.
3. Create it as a broadcast in Resend from announcements@example.com to the
   "Customers" segment, subject "We just launched".
4. Show me a summary and the dashboard link, but do not send it.
```

## Troubleshooting

* **Agent can't reach Paper**: make sure Paper Desktop is running with a file open, then restart your agent session.
* **Design looks different in the email**: email clients don't support modern CSS. Ensure you've installed the Resend's [agent skills](/docs/resend-skill). Then ask the agent to use table-based layout and inline styles, and to flag anything (like custom fonts or complex gradients) that won't survive the conversion.
* **`create-broadcast` fails**: check that the `from` address uses a [verified domain](https://resend.com/domains) and that the segment exists.


# Stripe Projects Integration
Source: https://resend.com/docs/guides/stripe-projects-integration

Provision Resend for a project directly from Stripe and start sending email.

Resend is a provider on [Stripe Projects](https://projects.dev). One command gives your project a Resend account and an API key, ready to send. No signup form, and your agent can run it for you.

## What you get

* A Resend account created and linked to your Stripe account.
* One API key per project, managed by Stripe and synced to your environment.
* Full access to the Resend dashboard and API.
* Paid plans for newly provisioned accounts are billed to your Stripe account, alongside your other Stripe Projects services.

One Stripe account maps to one Resend team. Each project gets its own API key, and all projects share the team's sending quota.

## Add Resend to a project

You need the [Stripe CLI](https://docs.stripe.com/stripe-cli) with the `projects` plugin installed, and a project to install Resend to:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
stripe plugin install projects
stripe projects init
```

Then, run:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
stripe projects add resend/email
```

> [!TIP]
>
> You can also ask your coding agent to run these steps. `stripe projects init`
> writes Stripe Projects skills into the project, and `add resend/email` adds a
> Resend skill, so the agent knows the CLI commands and the Resend API.

The CLI asks you to pick a plan (Free or Pro), provisions the account, and writes the API key to your local `.env` as `RESEND_API_KEY`. Run `stripe projects env` to list the variables with their values hidden.

### Which email Resend uses

Resend uses the email on your Stripe account, not the email you sign in to Stripe with. On a company account the two often differ. If you sign in as `bob@example.com` and the Stripe account's email is `company@example.com`, Resend provisions for `company@example.com`. That address owns the Resend account, and it is the only recipient your test emails can go to.

### Create or link

What happens next depends on whether that email already has a Resend account:

* No Resend account yet: the CLI creates one on the plan you picked.
* An existing Resend account: the CLI links a team where that email is an admin, and asks which team when there are several. The team's plan carries over, and its billing stays at Resend.

You can use your key to access all features from the [Resend API](https://resend.com/docs/api-reference).

To open the Resend Dashboard, already signed in, run:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
stripe projects open resend
```

To rotate the key, run `stripe projects rotate resend/email`. The CLI writes the new key to your `.env` and the old one stops working.

## Send your first email

You can send before you verify a domain. Use `onboarding@resend.dev` as the `from` address. The recipient must be the email on your Stripe account, the one Resend provisioned for. That is the only recipient the `resend.dev` testing domain can deliver to.

Install the SDK and read the key from the environment. Replace `you@example.com` with that address.

The SDKs read the process environment, not the `.env` file. Load it first, for example with `node --env-file=.env send.mjs`, or with your language's dotenv package.

```bash Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
composer require resend/resend-php
```

```bash Python theme={"theme":{"light":"github-light","dark":"vesper"}}
pip install resend
```

```bash Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
gem install resend
```

```bash Go theme={"theme":{"light":"github-light","dark":"vesper"}}
go get github.com/resend/resend-go/v4
```

```bash Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
cargo add resend-rs
cargo add tokio -F macros,rt-multi-thread
```

```bash Java theme={"theme":{"light":"github-light","dark":"vesper"}}
implementation 'com.resend:resend-java:+'
```

```bash .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
dotnet add package Resend
```

```elixir Elixir theme={"theme":{"light":"github-light","dark":"vesper"}}
def deps do
  [
    {:resend, "~> 0.4.0"}
  ]
end
```

Then send an email:

```js Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

const { data, error } = await resend.emails.send({
  from: 'onboarding@resend.dev',
  to: ['you@example.com'],
  subject: 'Hello from Stripe Projects',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
} else {
  console.log('Email sent:', data);
}
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
<?php

require __DIR__ . '/vendor/autoload.php';

$resend = Resend::client(getenv('RESEND_API_KEY'));

try {
    $result = $resend->emails->send([
        'from' => 'onboarding@resend.dev',
        'to' => ['you@example.com'],
        'subject' => 'Hello from Stripe Projects',
        'html' => '<strong>It works!</strong>',
    ]);
    echo 'Email sent: ' . $result['id'];
} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import os
import resend
from resend.exceptions import ResendError

resend.api_key = os.environ["RESEND_API_KEY"]

params: resend.Emails.SendParams = {
    "from": "onboarding@resend.dev",
    "to": ["you@example.com"],
    "subject": "Hello from Stripe Projects",
    "html": "<strong>It works!</strong>",
}

try:
    email = resend.Emails.send(params)
    print("Email sent:", email)
except ResendError as error:
    print(error)
```

```ruby Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = ENV["RESEND_API_KEY"]

params = {
  "from": "onboarding@resend.dev",
  "to": ["you@example.com"],
  "subject": "Hello from Stripe Projects",
  "html": "<strong>It works!</strong>"
}

sent = Resend::Emails.send(params)
puts "Email sent: #{sent[:id]}"
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"fmt"
	"os"

	"github.com/resend/resend-go/v4"
)

func main() {
	client := resend.NewClient(os.Getenv("RESEND_API_KEY"))

	params := &resend.SendEmailRequest{
		From:    "onboarding@resend.dev",
		To:      []string{"you@example.com"},
		Subject: "Hello from Stripe Projects",
		Html:    "<strong>It works!</strong>",
	}

	sent, err := client.Emails.Send(params)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Println("Email sent:", sent.Id)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
    let api_key = std::env::var("RESEND_API_KEY")
        .expect("RESEND_API_KEY not set");
    let resend = Resend::new(&api_key);

    let email = CreateEmailBaseOptions::new(
        "onboarding@resend.dev",
        ["you@example.com"],
        "Hello from Stripe Projects"
    ).with_html("<strong>It works!</strong>");

    match resend.emails.send(email).await {
        Ok(data) => println!("Email sent: {:?}", data),
        Err(e) => eprintln!("Error: {}", e),
    }

    Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.*;

public class Main {
    public static void main(String[] args) {
        Resend resend = new Resend(System.getenv("RESEND_API_KEY"));

        CreateEmailOptions params = CreateEmailOptions.builder()
            .from("onboarding@resend.dev")
            .to("you@example.com")
            .subject("Hello from Stripe Projects")
            .html("<strong>It works!</strong>")
            .build();

        try {
            CreateEmailResponse data = resend.emails().send(params);
            System.out.println("Email sent: " + data.getId());
        } catch (ResendException e) {
            e.printStackTrace();
        }
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( Environment.GetEnvironmentVariable( "RESEND_API_KEY" )! );

try
{
    var resp = await resend.EmailSendAsync( new EmailMessage()
    {
        From = "onboarding@resend.dev",
        To = "you@example.com",
        Subject = "Hello from Stripe Projects",
        HtmlBody = "<strong>It works!</strong>",
    } );
    Console.WriteLine( "Email sent: {0}", resp.Content );
}
catch ( ResendException ex )
{
    Console.WriteLine( "Error: {0}", ex.Message );
}
```

```elixir Elixir theme={"theme":{"light":"github-light","dark":"vesper"}}
client = Resend.client(api_key: System.get_env("RESEND_API_KEY"))

{:ok, result} = Resend.Emails.send(client, %{
  from: "onboarding@resend.dev",
  to: ["you@example.com"],
  subject: "Hello from Stripe Projects",
  html: "<strong>It works!</strong>"
})

IO.inspect(result)
```

See the full quickstart for [Node.js](/docs/send-with-nodejs), [PHP](/docs/send-with-php), [Python](/docs/send-with-python), [Ruby](/docs/send-with-ruby), [Go](/docs/send-with-go), [Rust](/docs/send-with-rust), [Java](/docs/send-with-java), [.NET](/docs/send-with-dotnet), or [Elixir](/docs/send-with-elixir).

## Add a domain

Resend sends emails using a domain you own. Before you can send or receive emails with Resend to addresses other than your own, you must have a verified domain associated with your account.

To send from your own domain, and to any recipient, [add and verify a domain](/docs/add-a-domain).

## Billing

Resend offers free and paid plans through Stripe Projects. Stripe manages the billing, so you pay for Resend the same way you pay for your other Projects services.

To upgrade, run:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
stripe projects upgrade resend/email
```

The CLI asks you to confirm the plan change, then shows the plans to pick from. In a script or from an agent, name the current plan and the target, and pass `--json`:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
stripe projects upgrade resend/free resend/pro --json
```

If Stripe has no payment method for you yet, the CLI stops and gives you a Checkout link to add one. The higher quota activates when the first payment confirms. To go back to the free plan, run `stripe projects downgrade resend/pro resend/free`. The paid quota stays until the billing period ends.

> [!WARNING]
>
> The Stripe Projects integration does not have paid marketing plans yet, only
> Transactional Pro. Discounts, promo codes, and startup or partner credits do
> not apply to Stripe Projects plans.

## Next steps

* Send your first email with [Next.js](/docs/send-with-nextjs).
* Explore [receiving emails](/docs/dashboard/receiving/introduction) with Resend.
* Use Resend [Templates](/docs/dashboard/templates/introduction) to simplify your email sending and design.
* Create your first Resend [Automation](/docs/dashboard/automations/introduction).


# Show Resend metrics on TRMNL
Source: https://resend.com/docs/guides/trmnl-integration

Add the Resend plugin to your TRMNL e-ink display to see email volume and deliverability at a glance.

[TRMNL](https://trmnl.com) is an e-ink display that rotates through screens from plugins. The official [Resend plugin](https://trmnl.com/recipes/resend-521360) shows how many emails your team sent and how many the recipient's mail server accepted, with the same numbers as your [Metrics](https://resend.com/metrics) page.

![Resend plugin on a TRMNL display](https://mintcdn.com/resend/H-2crYdwSrv8afiu/images/trmnl-full.png?fit=max\&auto=format\&n=H-2crYdwSrv8afiu\&q=85\&s=a6408695fab57dddb12f85d77771a195)

## What the plugin shows

The plugin covers the last 15 days, including today. That's the same default range as the Metrics page.

* **Emails:** The number of emails sent.
* **Deliverability:** The share of sent emails that the recipient's mail server accepted.
* **Bounces:** The share of sent emails that bounced.
* **Complaints:** The share of delivered emails that recipients marked as spam.
* **Chart:** Emails sent per day, bucketed by the time zone set in your TRMNL account.

If your team sent no emails in the range, the three rates show a dash instead of `0%`. Every account must stay under a [4% bounce rate](/docs/knowledge-base/account-quotas-and-limits#bounce-rate) and a [0.08% spam rate](/docs/knowledge-base/account-quotas-and-limits#spam-rate).

## Connect Resend

**1. Add the plugin**

Open the [Resend plugin](https://trmnl.com/recipes/resend-521360) in TRMNL and add it.

**2. Sign in to Resend**

1. Click **Connect**.
2. Sign in to Resend.
3. Approve access for your team.

The plugin uses OAuth, so you don't need to create or paste an API key. It requests `full_access` because the Metrics API requires it; this scope permits access to every API route, including write operations, though the plugin only reads metrics.

**3. Add it to a playlist**

Add the plugin to a TRMNL playlist. The display picks it up on its next refresh.

## Layouts

The plugin supports every TRMNL layout (full, half horizontal, half vertical, and quadrant). Use it on its own or in a mashup with other plugins.

The full layout shows all four numbers and a chart with axes.

![Resend plugin in the full layout](https://mintcdn.com/resend/H-2crYdwSrv8afiu/images/trmnl-full.png?fit=max\&auto=format\&n=H-2crYdwSrv8afiu\&q=85\&s=a6408695fab57dddb12f85d77771a195)

## How often it refreshes

TRMNL fetches new metrics from Resend every 15 minutes. The [Metrics API](/docs/api-reference/emails/get-metrics) also caches responses for up to 15 minutes, so the display can trail the Metrics page by up to about half an hour. When the display shows the new data depends on your device's own refresh rate.

## Troubleshooting

### The screen says "Couldn't load metrics"

The plugin couldn't read metrics from Resend, and the screen shows the error Resend returned. This usually means the connection's access was revoked or expired.

Open the plugin in TRMNL and click **Connect** again to sign in to Resend.

### The numbers don't match the Metrics page

Check these in order:

1. **Team:** The plugin shows the team you approved access for when you connected. Make sure you're viewing that team's Metrics page.
2. **Date range:** The plugin always shows the last 15 days. Set the Metrics page to the same range to compare.
3. **Time zone:** The chart groups days by the time zone in your TRMNL account settings. If that differs from the time zone you view the Metrics page in, the daily bars can shift by a day.
4. **Delay:** The display can trail the Metrics page by up to about 30 minutes. See [How often it refreshes](#how-often-it-refreshes).

## Contribute

The plugin is open source. To report a bug or change a layout, open an issue or pull request in the [resend-trmnl-plugin](https://github.com/resend/resend-trmnl-plugin) repository. The README covers how to preview changes locally with the TRMNL preview server.


# Vercel Marketplace Integration
Source: https://resend.com/docs/guides/vercel-marketplace-integration

Create and connect a Resend account directly from Vercel using the dashboard, the CLI, or v0.

The Resend integration on the [Vercel Marketplace](https://vercel.com/marketplace/resend) lets you provision a Resend account without leaving Vercel. Once installed, Vercel connects the account to your project so you can start sending email right away.

## What you get

* A Resend account created and linked to your Vercel account.
* A connection between that account and the Vercel project you selected.
* Access to the full [Resend dashboard](https://resend.com), where you can add domains, manage API keys, and view logs.

## Prerequisites

Before you begin, make sure you have the following:

* A Vercel account with a project.
* A domain purchased in Vercel.

## Three surfaces

You can add Resend to a Vercel project from any of these surfaces:

* [**Vercel Dashboard**](#vercel-dashboard)
* [**Vercel CLI**](#vercel-cli)
* [**v0**](#v0)

<video aria-label="Demonstration of installing Resend from the Vercel Marketplace" />

### Vercel Dashboard

To install Resend from the Vercel Marketplace:

1. Log in to Vercel and go to the [Marketplace](https://vercel.com/resend/~/integrations/marketplace).
2. Search for "Resend" and click on the integration card.
3. Click on the "Install" button.
4. To create a new Resend account for your Vercel project, click on the "Create Account" option and **Continue**.
5. Click **Accept and Create** to continue the installation.
6. Choose a domain in the selector. Use a domain already on your Vercel account, or purchase one from Vercel.
7. Select the region your emails will be sent from (defaults to North Virginia).
8. Select a plan (free or paid).
9. Click **Continue** and **Create** to complete the installation.
10. Select your Vercel project to connect the domain to Resend and click **Connect**.

Vercel creates a new Resend account for your Vercel project, connects the domain to Resend, and provisions an API key.

### Vercel CLI

Add Resend to the linked project from your terminal. With the [Vercel CLI](https://vercel.com/docs/cli) installed:

1. Run `vc i resend` from your project directory. To set the region your emails will be sent from, pass it as metadata: `-m region=eu-west-1` (defaults to `us-east-1`). Supported regions: `us-east-1`, `eu-west-1`, `sa-east-1`, and `ap-northeast-1`.
2. Choose a domain in the selector. Use a domain already on your Vercel account, or purchase one from Vercel.
3. Select the region your emails will be sent from (defaults to North Virginia).
4. Select a plan (free or paid).
5. Click **Continue** and **Create** to complete the installation.
6. Select your Vercel project to connect the domain to Resend and click **Connect**.
7. Click **Complete onboarding** to view the domain in your new Resend account.
8. Click **Auto configure** to automatically add the DNS records to your Vercel domain.

Get more help adding a custom domain in [Resend's documentation](/docs/dashboard/domains/introduction).

### v0

[v0](https://v0.dev) by Vercel is a platform for building web sites, tools, apps, and projects via chat. Ask v0 to add email with Resend, then click **Install** when the chat prompts you. That opens the same Marketplace install flow as the [Vercel Dashboard](#vercel-dashboard) and [Vercel CLI](#vercel-cli).

The integration creates a Resend account, adds a Resend API key to your v0 project's environment variables, and configures DNS for a domain purchased in Vercel. Billing is managed through v0.

See [Send emails with v0 and Resend](/docs/v0-integration) for the full walkthrough.

## Billing

Accounts created from the Marketplace are billed by Vercel. Manage your account from the Vercel installation dashboard.

> [!WARNING]
>
> Discounts, promo codes, and startup or partner credits do not apply to
> Marketplace plans.

## Next steps

* Send your first email with [Next.js](/docs/send-with-nextjs).
* Explore [receiving emails](/docs/dashboard/receiving/introduction) with Resend.
* Use Resend [Templates](/docs/dashboard/templates/introduction) to simplify your email sending and design.
* Create your first Resend [Automation](/docs/dashboard/automations/introduction).


# Integrations
Source: https://resend.com/docs/integrations

Integrate Resend with the tools you already use.

## Coding agents

> [card] [Cursor](https://www.resend.com/cursor)
>
> Send emails from Cursor with the Resend MCP server

> [card] [Claude](https://www.resend.com/claude)
>
> Connect Claude to Resend with the official connector

> [card] [Claude Code](https://www.resend.com/claude-code)
>
> Send emails from Claude Code with the official plugin

> [card] [Codex](https://www.resend.com/codex)
>
> Send emails from Codex with the official Resend plugin

> [card] [Antigravity](https://www.resend.com/antigravity)
>
> Send emails from Antigravity with the Resend MCP server

> [card] [Devin](https://www.resend.com/devin)
>
> Send emails from Devin with the Resend MCP server

> [card] [Gemini](https://www.resend.com/gemini)
>
> Build email automations with Gemini and Resend

> [card] [GitHub Copilot](https://www.resend.com/github-copilot)
>
> Send emails from GitHub Copilot with the Resend MCP server

> [card] [OpenCode](https://www.resend.com/opencode)
>
> Send emails from OpenCode with the Resend MCP server

> [card] [Zed](https://www.resend.com/zed)
>
> Send emails from Zed with the Resend MCP server

> [card] [Warp](https://www.resend.com/warp)
>
> Send emails from Warp with the Resend MCP server

> [card] [Hermes](https://www.resend.com/hermes)
>
> Install the Resend plugin in Hermes, MCP server and skills included

> [card] [OpenClaw](https://www.resend.com/openclaw)
>
> Send emails from OpenClaw with the Resend MCP server

> [card] [Grok Bot](https://www.resend.com/grokbot)
>
> Install the Resend plugin in Grok Bot

## AI

> [card] [v0](https://vercel.com/marketplace/resend)
>
> Add email to your v0 apps with the Vercel Marketplace

> [card] [Lovable](https://docs.lovable.dev/integrations/resend)
>
> Tell the Lovable AI to send emails

> [card] [Anything](https://www.createanything.com/docs/integrations/resend)
>
> Add email to your Anything projects

> [card] [Wildcard](https://github.com/wild-card-ai/agents-json/blob/master/examples/resend.ipynb)
>
> Send natural language emails using Wildcard

> [card] [mcp.run](https://www.mcp.run/nilslice/resend)
>
> Build email AI agents using mcp.run

> [card] [Rocket](https://docs.rocket.new/integrations/resend)
>
> Send emails from apps built with Rocket

> [card] [Base44](https://docs.base44.com/Integrations/Resend-integration)
>
> Add email to your Base44 apps

> [card] [Leap.new](https://docs.leap.new/integrations/resend)
>
> Add email to your Leap apps

> [card] [Parsley](https://www.parsley.id/integrations/resend)
>
> Buyer intent into Resend Segments

> [card] [Pica](https://www.picaos.com/integrations/resend)
>
> Integrate Pica with Resend

> [card] [camelAI](https://camelai.com/docs/getting-started/partners/resend)
>
> Add email to your camelAI apps

## No-code

> [card] [n8n](https://n8n.io/integrations/resend)
>
> Build email workflows using n8n

> [card] [Zapier](https://zapier.com/apps/resend/integrations)
>
> Automate emails using Zapier

> [card] [Email Element](https://docs.emailelement.com/en/SendIntegrations/Resend)
>
> Send emails using Email Element

> [card] [Pipedream](https://pipedream.com/apps/resend)
>
> Build workflows using Pipedream

> [card] [Activepieces](https://www.activepieces.com/pieces/resend)
>
> Build workflows using Activepieces

> [card]
>
> Quote and bill customers from Bunny
>
> [Open](https://docs.bunny.com/guide/advanced-guides/integrations/resend)

> [card] [Monkedo](https://monkedo.com/integrations/app/resend)
>
> Automate emails using Monkedo

> [card] [Make.com](https://www.make.com/en/integrations/resend)
>
> Build workflows using Make.com

> [card] [Lindy](https://www.lindy.ai/integrations/resend)
>
> Build workflows using Lindy

> [card] [BuildShip](https://buildship.com/integrations/resend)
>
> Build workflows using BuildShip

> [card] [viaSocket](https://viasocket.com/integrations/resend?utm_source=resend\&utm_medium=marketplace\&utm_campaign=resend_listing)
>
> Build automations using viaSocket

> [card] [Stacksync](https://www.stacksync.com/connectors/resend)
>
> Build automations using Stacksync

> [card]
>
> Use Resend as a data destination in ApiX-Drive
>
> [Open](https://apix-drive.com/en/integrations/resend)

> [card] [Post SMTP](https://postmansmtp.com/docs/mailers/how-to-setup-resend-with-post-smtp/)
>
> Send emails from WordPress with Post SMTP

> [card] [Softr](https://docs.softr.io/workflows/integrations/resend)
>
> Send emails from Softr apps and workflows

> [card] [Attio](/docs/guides/attio-integration)
>
> Send emails and add contacts to segments from Attio

> [card] [Gravity Forms](https://docs.gravitysmtp.com/category/integrations/resend/)
>
> Send emails from WordPress with Gravity Forms

## Notifications

> [card] [Courier](https://www.courier.com/docs/guides/providers/email/resend/)
>
> Trigger messages using Courier

> [card] [Novu](https://docs.novu.co/platform/integrations/email/resend)
>
> Send notifications using Novu

> [card] [Knock](https://docs.knock.app/integrations/email/resend)
>
> Send notifications using Knock

> [card] [Engagespot](https://docs.engagespot.co/docs/features/channels/email/resend/)
>
> Send notifications using Engagespot

> [card] [Dittofeed](https://docs.dittofeed.com/integrations/channels/resend)
>
> Send automated emails using Dittofeed

> [card] [Suprsend](https://docs.suprsend.com/docs/resend)
>
> Send notifications using Suprsend

## Content Management Systems

> [card] [Payload CMS](https://payloadcms.com/docs/email/overview#resend-configuration)
>
> Send emails using Payload CMS

> [card] [Strapi CMS](https://strapi.io/integrations/resend)
>
> Send emails using Strapi CMS

## Developer tools

> [card] [Laravel Cloud](/docs/guides/laravel-cloud-integration)
>
> Connect Resend to a Laravel Cloud environment

> [card] [Raycast](https://www.raycast.com/resend/resend)
>
> Manage emails, domains, and more

> [card] [Convex](https://www.convex.dev/components/resend)
>
> Send emails with Convex's Resend Component

> [card] [Inngest](https://www.inngest.com/docs/guides/resend-webhook-events)
>
> Send drip campaigns using Inngest

> [card] [Upstash](https://upstash.com/docs/qstash/integrations/resend)
>
> Send emails using Upstash

> [card] [Encore](https://encore.cloud/integrations/resend)
>
> Send emails backed by Encore's observability and infrastructure

> [card] [Trigger.dev](https://trigger.dev/docs/guides/examples/resend-email-sequence)
>
> Send drip campaigns using Trigger.dev

> [card] [Infisical](https://infisical.com/docs/self-hosting/configuration/envars#resend)
>
> Send email when self-hosting Infisical

> [card] [Fastgen](https://docs.fastgen.com/actions/integrations/resend)
>
> Build workflows using Fastgen

> [card] [Medusa](https://docs.medusajs.com/resources/integrations/guides/resend)
>
> Send e-commerce emails using Medusa

> [card] [OpenMeter](https://openmeter.io/docs/reporting/email)
>
> Send usage emails using OpenMeter

> [card] [Invopop](https://docs.invopop.com/guides/features/email)
>
> Send invoice emails using Invopop

> [card] [Tinybird](https://www.tinybird.co/docs/get-data-in/guides/ingest-from-resend)
>
> Analyze your email data in real time

> [card] [PostHog](https://posthog.com/docs/cdp/sources/resend)
>
> Sync Resend data to the PostHog data warehouse

> [card] [Coolify](https://coolify.io/docs/knowledge-base/notifications#resend-configuration)
>
> Send email notifications using Coolify

> [card] [Courrier](https://railsdesigner.com/courrier/)
>
> API-powered email delivery for Ruby apps

> [card] [Auth0](https://auth0.com/docs/customize/email/smtp-email-providers/resend)
>
> Send Auth0 transactional emails using Resend

> [card] [Kinde](https://docs.kinde.com/integrate/third-party-tools/kinde-resend-custom-smtp/)
>
> Send auth and billing emails using Kinde

> [card] [Pulsetic](https://help.pulsetic.com/article/492-setting-up-custom-email-for-status-page)
>
> Send status page notifications using Pulsetic

> [card] [brin](https://brin.sh/docs/integrations/resend)
>
> Scan inbound emails for phishing before your app processes them

> [card] [Playrunner](https://playrunner.dev/docs/integration-packages/resend/)
>
> Send and receive email in Playrunner workflows

> [card] [Appwrite](https://appwrite.io/docs/products/messaging/resend)
>
> Send emails using Appwrite Messaging

## Build your own integration

Here's how to build your own integration with Resend:

1. Read the documentation on [how to send emails](/docs/api-reference/emails/send-email).
2. Integrate with your product offering.
3. [Reach out to us](https://resend.com/help) to feature your product on this page.


# Introduction
Source: https://resend.com/docs/introduction

Resend is the email API for developers.

For all documentation in an index, see
[llms.txt](https://resend.com/docs/llms.txt). To view the full text of the
documentation, see [llms-full.txt](https://resend.com/docs/llms-full.txt).

To get started with Resend, you'll need:

1. Your own domain, [verified with Resend](/docs/add-a-domain)
2. [A Resend API key](/docs/create-an-api-key)

Then, you'll be ready to send [both types of emails](/docs/explore-sending-features):

* **Transactional emails:** personalized, event-driven communication
* **Marketing campaigns:** bulk email Broadcasts distributed to a contact list

## Quickstart

Learn how to get Resend set up in your project.

> [card] [Node.js Quickstart](/docs/send-with-nodejs)

> [card] [Next.js Quickstart](/docs/send-with-nextjs)

> [card] [Express Quickstart](send-with-express/)

> [card] [PHP Quickstart](send-with-php/)

> [card] [Laravel Quickstart](send-with-laravel/)

> [card] [Python Quickstart](/docs/send-with-python)

> [card] [Ruby Quickstart](/docs/send-with-ruby)

> [card] [Rails Quickstart](/docs/send-with-rails)

> [card] [Go Quickstart](/docs/send-with-go)

> [card] [Rust Quickstart](/docs/send-with-rust)

> [card] [Elixir Quickstart](/docs/send-with-elixir)

> [card] [Java Quickstart](/docs/send-with-java)

> [card] [.NET Quickstart](/docs/send-with-dotnet)

> [card] [CLI Quickstart](/docs/cli-quickstart)

## Explore

Discover the full range of features and capabilities.

> [card] [Emails](dashboard/emails)
>
> Visualize all the activity in your account.

> [card] [Domains](dashboard/domains/introduction)
>
> Ensure deliverability of your emails.

> [card] [Webhooks](/docs/webhooks/introduction)
>
> Notify your application about email events.


# 403 Error with Error Code 1010
Source: https://resend.com/docs/knowledge-base/403-error-1010

Learn how to resolve a 403 error caused by a missing User-Agent header when sending requests to the Resend API.

You may receive a 403 error with error code 1010 (`Access denied`) when sending requests to the Resend API. This happens because requests without a `User-Agent` header are blocked before they reach the API.

## The Problem

The Resend API requires all HTTP requests to include a `User-Agent` header. When your HTTP client doesn't send one, the request is rejected with a 403 status code and error 1010 before it ever reaches the API.

This can be confusing because:

* The error doesn't come from the Resend API itself
* Tools like `curl` automatically include a `User-Agent` header, so requests from the command line work fine
* The error message doesn't clearly indicate that the missing header is the cause

## How to Identify This Issue

* You're getting a 403 error, but your API key and domain are correct
* The error response contains an error code of `1010`
* The same request works when using `curl` from the command line

## Solution

Add a `User-Agent` header to your HTTP requests.

**Example with Node.js `fetch`:**

```javascript theme={"theme":{"light":"github-light","dark":"vesper"}}
fetch('https://api.resend.com/emails', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer re_123456789',
    'Content-Type': 'application/json',
    'User-Agent': 'my-app/1.0',
  },
  body: JSON.stringify({
    from: 'you@example.com',
    to: 'user@example.com',
    subject: 'Hello World',
    html: '<p>Hello World</p>',
  }),
});
```

> [!NOTE]
>
> If you're using a [Resend SDK](/docs/sdks), the `User-Agent` header is already
> included automatically. This issue typically only affects direct HTTP requests
> made without an SDK.

## Get more help

If you've added a `User-Agent` header and you're still getting a 403 error:

1. Verify that the header is being sent correctly by inspecting your outgoing request.
2. Ensure your API key is valid and has the necessary permissions.
3. Check that your domain is verified in the [Resend Domains page](https://resend.com/domains).
4. [Contact Resend support](https://resend.com/help) with details about your error.


# 403 Error Using Verified Domain
Source: https://resend.com/docs/knowledge-base/403-error-domain-mismatch

Learn how to resolve a 403 error caused by using a domain in your API request that doesn't match your verified domain.

A 403 error can occur when there's a mismatch between the domain you're using in your API request and the domain you've verified in Resend.

## The Problem

You've verified a domain (or subdomain) in Resend, but your API request is using a different domain.

**Example scenario:**

* You verified `sending.domain.com` in Resend
* Your API request is using `domain.com` (that is, without the `sending` subdomain)

## How to Identify This Issue

1. Check which domain you've verified in your [Resend Domains page](https://resend.com/domains).
2. Compare it with the domain you're using in [your API request's](https://resend.com/logs) `from` field.

## Solution

You have two options to resolve this:

**Option 1: Update your API request** (Recommended)

Update your API call to use the verified domain. For example, if you verified `sending.domain.com`, make sure your `from` field uses that exact domain:

```javascript theme={"theme":{"light":"github-light","dark":"vesper"}}
resend.emails.send({
  from: 'onboarding@sending.domain.com', // Use your verified domain
  to: 'user@example.com',
  subject: 'Hello World',
  html: '<p>Hello World</p>',
});
```

**Option 2: Delete and re-add the domain**

1. Delete the domain you've added in Resend
2. Add and verify the domain that matches what you're using in your API request

> [!WARNING]
>
> Make sure the domain in your API request exactly matches the domain you've
> verified in Resend, including any subdomains.

## If You're Still Having Issues

If you've verified that your domain matches and you're still getting a 403 error:

1. Verify that your domain is fully verified in the [Resend Domains page](https://resend.com/domains).
2. Double-check that the domain in your API request's `from` field exactly matches your verified domain
3. Ensure your API key has the necessary permissions.
4. [Contact Resend support](https://resend.com/help) with details about your error


# 403 Error Using resend.dev Domain
Source: https://resend.com/docs/knowledge-base/403-error-resend-dev-domain

Learn how to resolve a 403 error when using the resend.dev domain to send emails to recipients other than your own.

You may receive a 403 error with the following message when trying to send emails:

```
You can only send testing emails to your own email address (your-email-address@domain.com).
To send emails to other recipients, please verify a domain at resend.com/domains, and change
the `from` address to an email using this domain.
```

## The Problem

You're using the default `resend.dev` domain while sending to email addresses other than your own.

**Example scenario:**

* Your API request uses `from: 'onboarding@resend.dev'`
* You're trying to send to recipients other than your own email address

## Why This Happens

The `resend.dev` domain is only available for testing purposes and can only send emails to the email address associated with your Resend account. This restriction helps protect domain reputation and ensures proper email deliverability.

## Solution

To send emails to recipients other than your own email address, you need to add and verify your own domain in Resend:

1. Go to the [Domains page](https://resend.com/domains) in your Resend dashboard
2. Click **Add Domain**
3. Enter your domain name
4. Follow the verification steps to add the required DNS records
5. Once verified, update your API request to use your verified domain

> [!NOTE]
>
> For detailed instructions on verifying your domain, check out our [domain
> verification guide](/docs/dashboard/domains/introduction) or the DNS guide for your
> specific provider.

## If You're Still Having Issues

If you've verified your domain and updated your API request but you're still getting a 403 error:

1. Verify that your domain is fully verified in the [Resend Domains page](https://resend.com/domains).
2. Ensure the domain in your API request's `from` field uses your verified domain (not `resend.dev`).
3. Make sure you're not trying to send to your own email address when using `resend.dev`.
4. [Contact Resend support](https://resend.com/help) with details about your error.


# What are Resend account quotas and limits?
Source: https://resend.com/docs/knowledge-base/account-quotas-and-limits

Learn what quotas and limits apply to accounts.

Resend regulates email volume in three ways:

1. email volume (quota) - for [Transactional Email](/docs/knowledge-base/what-sending-feature-to-use#transactional-emails)
2. number of contacts - for [Marketing Email](/docs/knowledge-base/what-sending-feature-to-use#marketing-emails)
3. sending rate

These limits help improve your deliverability and likelihood of reaching your recipient's inbox.

> [!NOTE]
>
> Both **sent emails** and **received emails** (inbound) count towards your
> account's email quota. Each received email counts as 1 email against your
> daily and monthly limits, just like sent emails.

## Free Account Quotas and Limits

Free accounts have the following:

* Transactional emails: daily email quota of 100 emails/day and 3,000 emails/month. This quota includes both sent and received emails. Multiple `To`, `CC`, or `BCC` recipients in sent emails count as separate emails towards this quota. The daily quota is a UTC calendar day (00:00–24:00 UTC) and resets at midnight UTC. It is not a rolling 24-hour window from your first send or from when you hit the limit.

* Marketing emails: unlimited emails to up to 1,000 contacts per month.

* Domains: up to 3 verified domains.

* Inboxes: up to 3 inboxes.

## Paid Plan Quota

* Transactional Pro, Scale and Enterprise plans have no daily quota limits, though the plan tier will dictate the monthly email quota. Both sent and received emails count towards this monthly quota. To see your current month usage, view the [**Usage page**](https://resend.com/settings/usage). Multiple `To`, `CC`, or `BCC` recipients in sent emails count as separate emails towards the monthly quota.
* Marketing Pro, Enterprise plans have unlimited emails, though the plan tier will dictate the monthly contacts.
* Pro plans include 10 domains and Scale plans include 1,000 domains. Enterprise domain limits are set by contract. Pro and Scale plans can add 100 more domains with a [\$20/month add-on](/docs/knowledge-base/what-is-resend-pricing#add-ons).
* All plans include 3 inboxes. Paid transactional plans can enable pay-as-you-go for inboxes to create more at \$1 per inbox per month. See [Inbox Limits](#inbox-limits).

## Overage Limits

Paid plans can turn on pay-as-you-go overages, which let you keep sending emails after you reach your monthly quota. Overages are off until a team admin turns on **Transactional pay-as-you-go** on the [Usage page](https://resend.com/settings/usage). While they are off, sending stops at your monthly quota until the next billing cycle.

> [!NOTE]
>
> Overage sending is capped by an overage limit, set as a percentage of your monthly quota. The default is 400%, so you can send up to 5x your monthly quota in a billing cycle. Once you reach the limit, sending is paused until the next billing cycle.
>
> A team admin can change the overage limit on the [Usage page](https://resend.com/settings/usage), from 100% to 1,000% in steps of 100%.

> [!TIP]
>
> While overages provide flexibility for occasional spikes in email volume, they
> can be more expensive per email than upgrading your plan. If you consistently
> exceed your quota, consider [upgrading to a higher
> tier](https://resend.com/settings/billing) for better value and more
> predictable costs.

## Domain Limits

Every plan includes a set number of verified custom domains, listed on the [pricing page](https://resend.com/pricing). You can see how many domains your team is using on the [**Usage page**](https://resend.com/settings/usage).

If you need more, paid transactional plans can enable the domains add-on, which adds 100 domains on top of the number included in your plan for \$20 per month. See [How to add more domains](/docs/knowledge-base/how-to-add-more-domains).

## Inbox Limits

Every plan includes 3 [inboxes](/docs/api-reference/inboxes/create-inbox) for free. To create more, enable pay-as-you-go for inboxes on the [**Usage page**](https://resend.com/settings/usage). Each inbox beyond the included 3 costs \$1 per month. Pay-as-you-go for inboxes requires a paid transactional plan, so free accounts need to [upgrade](https://resend.com/settings/billing) first.

You can see how many inboxes your team is using on the [**Usage page**](https://resend.com/settings/usage).

> [!NOTE]
>
> Pay-as-you-go for inboxes is off by default and can only be turned on by a
> team admin. Turning it off later stops new inboxes from being created, but
> existing inboxes keep working and keep being billed until you delete them.

## Rate Limits

All accounts start with a rate limit of 10 requests per second. The [rate limits](/docs/api-reference/rate-limit) follow the [IETF standard](https://datatracker.ietf.org/doc/html/draft-ietf-httpapi-ratelimit-headers) for stating the rate limit in the response header. If you have specific requirements, [contact support](https://resend.com/help) to request a rate increase.

The rate limit is enforced as a per-second window. There is no separate burst allowance above the stated limit. If your limit is 10 requests per second, an eleventh request in the same second window will receive a `429` response.

### Rate limit scope

The rate limit is **per team**, not per API key or per domain. All API keys associated with your team share the same rate limit pool. If you have multiple services or applications sending through the same Resend team, their requests count together toward the 10 req/sec limit.

For example, if Service A sends 6 requests and Service B sends 4 requests in the same second, you have hit your 10 req/sec limit for that window. Any additional requests from either service will receive a `429` response.

### High-volume workloads

If you have potential sending spikes or sustained high-volume workloads, consider these approaches:

* **Batch sending**: Use the [Batch Email API](/docs/api-reference/emails/send-batch-emails) to send up to 100 emails in a single API call. Each batch request counts as one request against your rate limit.
* **Client-side throttling**: Use the [rate Limit headers](/docs/api-reference/rate-limit) to configure client-side throttling.
* **Traffic spikes**: If you anticipate sustained traffic above your current limit, [contact support](https://resend.com/help) in advance to request a rate increase.

## Bounce Rate

All accounts must maintain a bounce rate of under **4%**. The [**Metrics page**](https://resend.com/metrics) within an account and/or [webhooks](https://resend.com/docs/webhooks/event-types#email-bounced) allow you to monitor your account bounce rates.

Maintaining a bounce rate above 4% may result in a temporary pause in sending until the bounce rate is reduced.

Tips to keep a bounce rate low:

* Remove inactive user email addresses from email lists.
* Only send to recipients who have given consent to receive email.
* When testing, avoid sending to fake email addresses. Use Resend's [test email addresses](/docs/dashboard/emails/send-test-emails) instead.
* If you are using open/click tracking, periodically remove recipients who are not engaging with your emails from your email lists.

## Spam Rate

All accounts must have a spam rate of under **0.08%**. The [**Metrics page**](https://resend.com/metrics) within an account and/or [webhooks](https://resend.com/docs/webhooks/event-types#email-complained) allow you to monitor your account spam rates.

Maintaining a spam rate over 0.08% may result in a temporary pause in sending until the spam rate is reduced.

Tips to keep a spam rate low:

* Give recipients a clear way to opt out of emails.
* Send relevant and timely emails.
* Only send to recipients who have given consent to receive email.

## Data Retention

Resend retains email data for **30 days** across all plans (Free, Pro, and Scale). This includes:

* Email content and metadata
* Delivery status and events
* Logs and metrics

Enterprise plans have access to **flexible data retention** options. [Contact support](https://resend.com/help) to discuss custom retention requirements.

> [!TIP]
>
> If you need access to historical email data beyond the 30-day retention
> window, consider storing [webhook
> events](/docs/webhooks/how-to-store-webhooks-data) in your own database. This gives
> you full control over retention periods and ensures you never lose important
> information.


# Audience Hygiene: How to keep your Audiences in good shape?
Source: https://resend.com/docs/knowledge-base/audience-hygiene

Learn strategies for maintaining good audience hygiene and maximizing email deliverability.

Audience hygiene (*also known as list hygiene*) refers to the practice of keeping your email list clean, valid, and engaged.

Maintaining proper audience hygiene is crucial for ensuring that your emails reach their intended recipients, maximizing your deliverability, and improving your sender reputation.

By removing invalid, outdated, or disengaged contacts, you can improve the effectiveness of your email campaigns. You'll also avoid issues like high bounce rates, low engagement, and even being marked as spam.

***

# How to ensure emails are valid

To keep your list healthy, it's essential to ensure that the email addresses you collect are valid, accurate, and belong to recipients who are truly interested in hearing from you. Here are a few strategies to help you achieve this:

### Prevent undesired or bot signups with CAPTCHA

Bots can sign up for your emails with little friction, inflating your list with fake or low-quality contacts. To help protect against bot signups, implement CAPTCHA systems during the sign-up process. CAPTCHA challenges help ensure that sign-ups come from human users and not bots or automated scripts.

Some popular CAPTCHA services include:

* **[Google reCAPTCHA](https://developers.google.com/recaptcha)**: One of the most widely used CAPTCHA services, offering both simple and advanced protection options.
* **[hCaptcha](https://www.hcaptcha.com/)**: An alternative to Google reCAPTCHA, providing similar protection but with a different user experience.
* **[Friendly Captcha](https://friendlycaptcha.com/)**: A privacy-focused CAPTCHA solution that doesn’t require users to click on anything, reducing friction in the sign-up process.

Using these tools will help reduce bot sign-ups and ensure your email list consists of real users.

### Ensure the recipient is consenting with Double Opt-In

Double opt-in is the process of confirming a user's subscription after they’ve signed up for your emails.

When a user submits their email address, you send them a confirmation email with a link they must click to complete the subscription process.

This step ensures that the person who entered the email address is the one who actually wants to receive your communications.

This is important to ensure:

* **Compliance with local regulations**: Double opt-in helps ensure that you comply with email marketing regulations such as the **CAN-SPAM Act** (U.S.) and **CASL** (Canada). Both of these laws require clear consent from subscribers before you can send them marketing emails.
* **Improved deliverability**: Double opt-in helps you maintain a clean list of genuinely interested users. This reduces bounce rates and prevents spam complaints, which in turn helps maintain your sender reputation with ISPs and inbox providers.
* **Verification of accuracy**: Double opt-in ensures the email addresses you collect are valid, accurate, and up to date, reducing the risk of sending to invalid addresses and impacting your deliverability.

### Use a third-party service to verify an address' deliverability

While you can verify that an email address follows the correct syntax (e.g., [user@example.com](mailto:user@example.com)) (also known as RFC 5322), you also need to ensure that the address is deliverable, that is, it’s an active inbox that can receive emails.

Third-party email verification services can help you identify whether an email address is valid, reachable, or likely to result in a bounce.

This reduces the risk of sending to addresses that won’t receive your emails and improves your overall deliverability.

Some email verification services include:

* **[Emailable](https://emailable.com/partners/resend)**
* **ZeroBounce**
* **Kickbox**

By using these services, you can clean up your existing email lists or prevent undeliverable emails to be added to them. This helps prevent unnecessary deliverability issues.

***

# How to proactively remove emails from your Segments

Over time, certain recipients may become disengaged with your content. It's important to manage your segments by removing inactive or unengaged users.

Regularly filtering your segments ensures that you're sending to only those who are actively interested, which in turn boosts engagement and deliverability.

A healthy email list is one that is continuously nurtured with relevant and timely content. Instead of sporadic communication, maintain consistent engagement with your audience to keep them interested.

### Filter on engagement

To keep your email list in top shape, focus on sending to engaged users. Major inbox providers like Gmail and Microsoft expect you to send emails to recipients who have recently opened or clicked on your emails.

As a best practice, limit non-transactional email sends to recipients who have opened or clicked an email in the past 6 months.

> [!NOTE]
>
> The exact timeframe may vary depending on your industry, sending frequency,
> and audience behavior, but 6 months is a generally accepted standard.

Regularly cleaning your list of disengaged recipients helps maintain a positive sender reputation and boosts your chances of landing in the inbox instead of the spam folder.

### Automatically remove bounced recipients

Using our [Webhooks](/docs/webhooks/introduction), you can be notified when a delivery bounces or gets marked as spam by the recipient.

This allows you to proactively unsubscribe the recipient and prevent further sending. Resend will automatically suppress further deliveries to that email address but will not automatically unsubscribe it for you.

### Sunset unengaged recipients

If certain recipients have not engaged with your emails over an extended period (e.g., 6+ months), consider removing them from your Marketing sends.

Continuing to send to these unengaged users can harm your deliverability by increasing bounce rates and decreasing your open rates.

To re-engage these users, you may want to send a re-engagement campaign or offer an incentive for them to stay on your list. If they don't respond, it's often best to remove them to keep your list healthy and avoid wasting resources on inactive contacts.

***

Audience hygiene involves validating email addresses, ensuring consent, verifying deliverability, and removing unengaged recipients. By maintaining these practices, you'll improve your email deliverability and foster better relationships with your subscribers.

This will help you achieve better engagement rates and a healthier sender reputation with inbox providers.


# Do You Need 2048-bit DKIM?
Source: https://resend.com/docs/knowledge-base/do-i-need-2048-dkim

Learn why 1024-bit DKIM is enough for transactional and marketing mail, and how it compares to 2048-bit keys.

**For almost every sender, you do not need 2048-bit DKIM.** This additional level of security can result in performance and compatibility issues with some systems.

To balance these concerns, Resend signs outbound mail with 1024-bit DKIM keys, which are RFC-compliant, accepted by every major mailbox provider, and satisfy the bulk sender requirements that inbox service providers enforce. Resend does not support 2048-bit DKIM keys.

You can't change the key length, and Resend doesn't rotate or regenerate keys on request. The key Resend creates when you add a domain stays with that domain, even if you delete the domain and add it again to that team.

## 1024-bit is RFC-compliant

[RFC 8301 §3.2](https://datatracker.ietf.org/doc/html/rfc8301#section-3.2) establishes 1024 bits as the minimum length verifiers must support and recommends signers use keys of at least 1024 bits. Mailbox providers including Gmail, Outlook, Yahoo, and Apple all accept 1024-bit DKIM signatures, and 1024-bit keys remain widely used across the industry for transactional and marketing mail.

## 1024-bit meets bulk sender requirements

The 2024 bulk sender requirements from Google, Yahoo, and Microsoft (which apply to anyone sending more than 5,000 messages per day to their users) require DKIM authentication alongside SPF and DMARC. **None of them mandate a specific DKIM key length**. 1024-bit DKIM signing fully satisfies these requirements, and Resend's domain setup gives you DKIM out of the box.

## 1024-bit vs 2048-bit keys

| | 1024-bit | 2048-bit |
| - | - | - |
| **Security** | Meets current RFC recommendations for email signing | Stronger cryptographic margin, better future-proofing |
| **Performance** | Faster signing and verification | More system resources required, can add latency |
| **DNS compatibility** | Fits comfortably in a single TXT record | Longer public key. Some DNS providers require splitting the record or hit character limits |
| **Setup** | Straightforward, works with every DNS provider you'll encounter | Requires careful setup. Misconfigured records can fail verification |

## Trade-offs of 2048-bit

* **Delivery latency.** Larger keys take longer to sign and verify on every message, which can add delay at scale.
* **DNS friction.** Most DNS providers now support the longer TXT record length needed for 2048-bit public keys, but some still impose character limits or require the value to be split into multiple strings. That's a common source of broken DKIM records and failed verifications.
* **No deliverability upside.** Inbox providers do not reward 2048-bit signatures with better placement.

## Our stance

For transactional and marketing mail, **1024-bit DKIM is the right choice.** It meets the RFC, satisfies bulk sender requirements from every major inbox provider, and keeps DNS setup simple and reliable.

> [!NOTE]
>
> If your security or compliance team has a specific requirement for 2048-bit
> DKIM, [let us know](https://resend.com/help).


# Does Resend require production approval?
Source: https://resend.com/docs/knowledge-base/does-resend-require-production-approval

Learn about production access and account limitations on Resend.

No, Resend does not require production approval. All accounts, including free accounts, have immediate production access from the moment you sign up.

## Free accounts have production access

Free accounts on Resend have full production access immediately. There is no sandbox mode, no approval process, and no waiting period. You can start sending transactional emails to your customers right away.

> [!NOTE]
>
> Resend does not limit free accounts or require authorization to send
> production emails. All accounts have the same production capabilities from day
> one.

## Common misconceptions

Some users may think they need production approval if:

* **DNS records aren't generated yet**: If you've added a domain but haven't completed DNS verification, the domain will show as "Pending" until you add the required DNS records. Once you add and verify your DNS records, the domain will show as verified and you can send from that domain.

* **Coming from other email services**: Some email service providers do require production approval or have sandbox modes. Resend does not have these restrictions.

## Getting started

To start sending emails with Resend:

1. [Sign up for a Resend account](https://resend.com/signup)
2. [Add and verify your domain](https://resend.com/domains)
3. [Create an API key](https://resend.com/api-keys)
4. Start sending emails immediately

If you're having trouble with domain verification or DNS records, see our [domain verification troubleshooting guide](/docs/knowledge-base/what-if-my-domain-is-not-verifying) or check our [DNS setup guides](/docs/knowledge-base/introduction) for your specific DNS provider.


# Domain Already Registered by Another Account
Source: https://resend.com/docs/knowledge-base/domain-already-registered

Resolve the 403 domain already registered error by verifying domain ownership or starting a self-serve claim.

## Overview

When you add a domain to Resend, you may see this error: `The example.com domain has been registered already`.

This means the domain is associated with a different Resend account. A domain can only be active on one Resend account at a time.

## Why This Happens

Common reasons a domain may already be registered:

* A team member or contractor added it to a separate account.
* You are logged in to a different account than the one where the domain was originally added.

## How to Resolve It

### Check your existing accounts first

1. Check with your team to see if someone is already using Resend.
2. Make sure you're logged in to the right account.

### Claim the domain

If the domain belongs to a different team and you can prove ownership, you can claim it through a self-serve process:

1. Go to [Domains](https://resend.com/domains) and click **Add Domain**.
2. Enter the domain name and submit the form.
3. A prompt will appear explaining that the domain is in use by another Resend team. Click **Start claim** to begin.
4. Add the DNS TXT record provided to your domain's DNS settings to prove ownership.

The claim expires in 7 days. If you started a claim previously, you can pick up where you left off by submitting the same domain name again and clicking **Continue claim**.

If you cannot add DNS records or need further assistance, contact [Resend support](https://resend.com/help).

## Related Resources

* [What if my domain is not verifying?](/docs/knowledge-base/what-if-my-domain-is-not-verifying)
* [DNS provider setup guides](/docs/knowledge-base/introduction)


# Where to find Resend documents like DPA or W-9
Source: https://resend.com/docs/knowledge-base/downloading-documents

How to download compliance and tax documents from your Resend account.

Resend keeps your account's compliance and tax documents in one place: [Settings → Documents](https://resend.com/settings/documents).

> [!NOTE]
>
> You must be logged in to your Resend account to access the
> [Documents](https://resend.com/settings/documents) page.

## What's on the page

* **Penetration test**: Penetration testing is performed at least annually by third-party cybersecurity company Oneleet. The Letter of Attestation is available to download.
* **SOC 2**: Resend is SOC 2 Type II compliant under the framework developed by the AICPA. This audit was completed by Vanta & Advantage Partners and covers the period of February 1, 2025 to February 1, 2026. The full report is available to download.
* **DPA**: The Data Processing Agreement governs how Resend processes data on your behalf. The version on this page is pre-signed by Resend and is considered fully executed once you sign up for an account, so no counter-signature is required.
* **Form W-9**: The W-9 provides Resend's U.S. taxpayer identification number for vendor onboarding and accounts payable.

## Related pages

* [Sub-processors](https://resend.com/legal/subprocessors)
* [Unsigned DPA](https://resend.com/legal/dpa)


# Embed the React Email editor in your app
Source: https://resend.com/docs/knowledge-base/embed-react-email-editor

Add the open-source React Email editor to your application: base component, styling, Inspector sidebar, and custom extensions.

The [React Email editor](https://react.email/docs/editor/overview) is an open-source visual editor that lets your users author email templates inside your own product. It ships with bubble menus, slash commands, an Inspector sidebar, and extensible nodes. It also exports email-ready HTML you can hand straight to Resend.

This guide walks through embedding the editor in a React app, styling it to match your brand, customizing the Inspector Sidebar, and adding your own custom node.

[YouTube video player](https://www.youtube.com/embed/zhIT3NYEcMw)

## Prerequisites

* A React 18+ application (for example, Vite, Next.js, or Remix)
* A bundler with [package exports](https://nodejs.org/api/packages.html#exports) support (the defaults for the frameworks above)

**1. Install the editor**

Install `@react-email/editor` and import the bundled theme stylesheet once at your app root.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install @react-email/editor
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add @react-email/editor
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add @react-email/editor
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add @react-email/editor
```

```tsx app/layout.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import '@react-email/editor/themes/default.css';
```

The bundled theme covers the bubble menus, slash commands, and Inspector. If you only use a subset, you can [import individual stylesheets](https://react.email/docs/editor/getting-started#import-css) instead.

**2. Mount the base editor**

The fastest path is the standalone `EmailEditor` component. It comes with the default extensions, bubble menus, slash commands, and theming wired up.

```tsx app/components/Editor.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
'use client';

import { EmailEditor } from '@react-email/editor';

const initialContent = `
  <h1>Welcome</h1>
  <p>Type "/" for a command, or select text to format it.</p>
`;

export function Editor() {
  return <EmailEditor content={initialContent} />;
}
```

`content` accepts an HTML string or a TipTap JSON document. See the [`EmailEditor` API reference](https://react.email/docs/editor/api-reference/email-editor) for the full prop list.

> [!TIP]
>
> If you need full control over which extensions load, the provider layout, or
> the UI overlays, drop down to the [lower-level
> setup](https://react.email/docs/editor/getting-started#lower-level-setup) with
> `EditorProvider` from `@tiptap/react`.

**3. Style the editor**

The editor exposes two layers of styling:

1. **Editor chrome** (bubble menus, slash command palette, Inspector controls) — driven by CSS custom properties (`--re-*`) and `data-re-*` attribute selectors.
2. **Editor content** (what the user is typing) — uses TipTap's `.tiptap` root class. Note that styling here only affects the in-editor preview; the exported HTML is styled by the [theming system](https://react.email/docs/editor/features/theming).

Override the CSS variables on a wrapper class to apply your brand:

```css app/styles/editor.css theme={"theme":{"light":"github-light","dark":"vesper"}}
.brand-editor {
  --re-bg: #fafaf9;
  --re-border: #d6d3d1;
  --re-text: #1c1917;
  --re-text-muted: #78716c;
  --re-hover: rgba(28, 25, 23, 0.04);
  --re-active: rgba(28, 25, 23, 0.08);
  --re-radius: 0.5rem;
  --re-radius-sm: 0.25rem;
}

/* Target a specific bubble menu button */
[data-re-bubble-menu-item][data-active] {
  background: #2563eb;
  color: #fff;
}

/* Style the user's content area inside the editor */
.tiptap h1 {
  font-size: 1.75rem;
  letter-spacing: -0.025em;
}
```

```tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
<div className="brand-editor">
  <EmailEditor content={initialContent} />
</div>
```

The default theme also responds to `prefers-color-scheme: dark` and to a `.dark` class on any ancestor — so it works with libraries like `next-themes` out of the box. See the [Styling reference](https://react.email/docs/editor/features/styling) for the complete list of variables, `data-re-*` selectors, and content classes.

**4. Add the Inspector Sidebar**

The Inspector is a contextual sidebar that swaps panels based on the user's current selection — document defaults when nothing is focused, node properties when a block is selected, text formatting when text is selected.

Pass `Inspector.Root` as a child of `EmailEditor` so it shares the editor's context:

```tsx app/components/Editor.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
'use client';

import { EmailEditor } from '@react-email/editor';
import { Inspector } from '@react-email/editor/ui';

export function Editor() {
  return (
    <div className="flex" style={{ height: '600px' }}>
      <EmailEditor
        content="<h1>Hello</h1><p>Click any element to inspect it.</p>"
        className="flex-1 min-w-0 overflow-y-auto p-4"
      >
        <Inspector.Root className="w-72 shrink-0 border-l p-4 overflow-y-auto">
          <Inspector.Breadcrumb />
          <Inspector.Document />
          <Inspector.Node />
          <Inspector.Text />
        </Inspector.Root>
      </EmailEditor>
    </div>
  );
}
```

See the [Inspector reference](https://react.email/docs/editor/features/inspector) for every render-prop helper, the full list of reusable section components (`Inspector.Size`, `Inspector.Padding`, `Inspector.Border`, `Inspector.Typography`, `Inspector.Background`, `Inspector.Link`), and runnable examples.

**5. Add a custom extension**

Custom blocks use `EmailNode`, which extends TipTap's `Node` with the `renderToReactEmail` method so the same node renders correctly inside the editor and in the exported email.

> [!NOTE]
>
> See [Custom
> Extensions](https://react.email/docs/editor/advanced/custom-extensions) for
> the full API and a worked example.

**6. Send the result with Resend**

If you use the standalone `EmailEditor` component, you can access the email HTML and plain text through ref methods. In your handler, send the HTML to Resend using the [Send Email](/docs/api-reference/emails/send-email) or [Send Batch Emails](/docs/api-reference/emails/send-batch-emails) API.

```tsx theme={"theme":{"light":"github-light","dark":"vesper"}} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { EmailEditor, type EmailEditorRef } from '@react-email/editor';
import { useRef, useState } from 'react';

export function MyEditor() {
  const ref = useRef<EmailEditorRef>(null);

  const handleExport = async () => {
    if (!ref.current) return;
    const html = await ref.current.getEmailHTML();
    // Send email using Resend using a server-side API endpoint/action
    const response = await fetch('/api/send-email', {
      method: 'POST',
      body: JSON.stringify({ html }),
    });
  };

  return (
    <div>
      <EmailEditor ref={ref} content="<p>Edit me</p>" />
      <button onClick={handleExport}>Export HTML</button>
    </div>
  );
}
```

The ref exposes three export methods:

| Method | Returns | Description |
| - | - | - |
| `getEmailHTML()` | `Promise<string>` | Email-ready HTML |
| `getEmailText()` | `Promise<string>` | Plain text version |
| `getEmail()` | `Promise<{ html, text }>` | Both in a single call |

All three use [composeReactEmail](https://react.email/docs/editor/api-reference/compose-react-email) under the hood.

> [!NOTE]
>
> See [Email Export docs](https://react.email/docs/editor/features/email-export)
> for more information on the export methods.

## Next steps

> [card] [React Email editor reference](https://react.email/docs/editor/overview)
>
> The complete API surface — extensions, UI components, theming, and image
> upload.

> [card] [Editor styling reference](https://react.email/docs/editor/features/styling)
>
> Every CSS variable and `data-re-*` selector you can target.

> [card] [Custom extensions](https://react.email/docs/editor/advanced/custom-extensions)
>
> Wrap existing TipTap extensions or build new email-safe nodes and marks.

> [card] [Template emails with React Email](/docs/knowledge-base/template-emails-with-react-email)
>
> Author templates as `.tsx` files and upload them to Resend with the CLI.


# How to set up E2E testing with Playwright
Source: https://resend.com/docs/knowledge-base/end-to-end-testing-with-playwright

End to end testing ensures your entire app flow is fully functioning.

Below is a basic guide on setting up E2E testing with NextJS, Resend, and Playwright.

Prefer watching a video? Check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/lzozXSMKl6E)

## Guide

**1. Create an endpoint**

For simplicity, we'll create a GET endpoint that sends an email to the testing account, `delivered@resend.dev` on fetch.

```ts app/api/send/route.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
const resend = new Resend(process.env.RESEND_API_KEY);

export async function GET() {
  try {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello world',
      html: '<h1>Hello world</h1>',
    });

    if (error) {
      return Response.json({ error }, { status: 500 });
    }

    return Response.json({ data });
  } catch (error) {
    return Response.json({ error }, { status: 500 });
  }
}
```

**2. Write the test spec file**

Create a test spec file at `e2e/app.spec.ts`. You can test in two ways: by calling the Resend API or by mocking a response.

Calling the Resend API tests the entire API flow, including Resend's API responses, but counts towards your account's sending quota.

```ts e2e/app.spec.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { test, expect } from '@playwright/test';

test('does not mock the response and calls the Resend API', async ({
  page,
}) => {
  // Go to the page
  await page.goto('http://localhost:3000/api/send');

  // Assert that the response is visible
  await expect(page.getByText('id')).toBeVisible();
});
```

Mocking the response lets you test your app's flow without calling the Resend API and impacting your account's sending quota.

```ts e2e/app.spec.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { test, expect } from '@playwright/test';

test("mocks the response and doesn't call the Resend API", async ({ page }) => {
  // Sample response from Resend
  const body = JSON.stringify({
    data: {
      id: '621f3ecf-f4d2-453a-9f82-21332409b4d2',
    },
  });

  // Mock the api call before navigating
  await page.route('*/**/api/send', async (route) => {
    await route.fulfill({
      body,
      contentType: 'application/json',
      status: 200,
    });
  });
});
```

> [!NOTE]
>
> However you test, it's important to test using a test email address (e.g.,
> [delivered@resend.dev](mailto:delivered@resend.dev)) so your tests don't impact your deliverability. Resend's
> [test accounts](/docs/dashboard/emails/send-test-emails) run through the entire API
> flow without harming your reputation.

**3. Create a Playwright config file**

Write your config file, paying special attention to a few properties:

* `testDir`: the directory containing your test files
* `outputDir`: the directory to store test results
* `webServer`: provide instructions for Playwright to run your app before starting the tests
* `projects`: an array of the browsers you want to test

```ts playwright.config.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { defineConfig, devices } from '@playwright/test';
import path from 'path';

const baseURL = 'http://localhost:3000';

export default defineConfig({
  timeout: 30 * 1000,
  testDir: path.join(__dirname, 'e2e'),
  retries: 2,
  outputDir: 'test-results/',
  webServer: {
    command: 'npm run dev',
    url: baseURL,
    timeout: 120 * 1000,
    reuseExistingServer: !process.env.CI,
  },

  use: {
    baseURL,
    // Retry a test if its failing with enabled tracing. This allows you to analyze the DOM, console logs, network traffic etc.
    trace: 'retry-with-trace',
  },

  projects: [
    // Test against desktop browsers.
    {
      name: 'Desktop Chrome',
      use: {
        ...devices['Desktop Chrome'],
      },
    },
    {
      name: 'Desktop Firefox',
      use: {
        ...devices['Desktop Firefox'],
      },
    },
    {
      name: 'Desktop Safari',
      use: {
        ...devices['Desktop Safari'],
      },
    },
    // Test against mobile viewports.
    {
      name: 'Mobile Chrome',
      use: {
        ...devices['Pixel 5'],
      },
    },
    {
      name: 'Mobile Safari',
      use: devices['iPhone 12'],
    },
  ],
});
```

[See the Playwright docs](https://playwright.dev/docs/intro) for more help.

**4. Run the test**

You can run the test by installing Playwright and running the tests.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx playwright install
npx playwright test
```

Playwright will run the tests in the browsers of your choice and show you the results.

## Examples

> [card] [Example repo](https://github.com/resend/resend-nextjs-playwright-example)
>
> See the full source code.


# Eve
Source: https://resend.com/docs/knowledge-base/eve

Connect to your Eve agent over email.

[Eve](https://eve.dev/) is an open-source framework for building agents created by Vercel. It's filesystem-first, inspired by Next.js, and provides tools, workflows, connections, hooks, and channels for you to build long-running, durable agents.

Using the [Resend adapter for the Vercel Chat SDK](/docs/chat-sdk) you can plug in email as a channel to your eve agent.

## Prerequisites

To get started, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)
* [Set up webhooks](/docs/webhooks/introduction) for `email.received` events
* [Enable receiving](/docs/dashboard/receiving/introduction) on your domain

## Guide

**1. Install**

Create a new project with eve and then install the Chat SDK, the Resend adapter, and the development state adapter.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npx eve@latest init my-agent
cd my-agent
npm install @resend/chat-sdk-adapter chat @chat-adapter/state-memory
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn dlx eve@latest init my-agent
cd my-agent
yarn add @resend/chat-sdk-adapter chat @chat-adapter/state-memory
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm dlx eve@latest init my-agent
cd my-agent
pnpm add @resend/chat-sdk-adapter chat @chat-adapter/state-memory
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bunx eve@latest init my-agent
cd my-agent
bun add @resend/chat-sdk-adapter chat @chat-adapter/state-memory
```

**2. Configure the adapter**

Create the Resend adapter with the [adapter configuration options](#configuration-options). Then create a Chat SDK channel with the adapter, a username for the bot, and an adapter state. `streaming` should be set to false as emails can only deliver one message per turn.

Export the `channel` object and the framework will integrate it automatically.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { createResendAdapter } from '@resend/chat-sdk-adapter';
import { chatSdkChannel } from 'eve/channels/chat-sdk';
import { createMemoryState } from '@chat-adapter/state-memory';

export const resendAdapter = createResendAdapter({
  fromAddress: 'bot@example.com',
  fromName: 'My Bot',
});

export const { bot, channel, send } = chatSdkChannel({
  adapters: { resend: resendAdapter },
  userName: 'My Bot',
  state: createMemoryState(),
  streaming: false,
});

export default channel;
```

> [!NOTE]
>
> Set `RESEND_API_KEY` and `RESEND_WEBHOOK_SECRET` as environment variables. You can also pass `apiKey` and `webhookSecret` directly in the config passed to `createResendAdapter` — explicit values take precedence over env vars.

**3. Handle new messages**

Register handlers for incoming messages. `onNewMention` event fires when a new thread starts and `onSubscribedMessage` fires for follow-up emails in threads you are already subscribed to.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
bot.onNewMention(async (thread, message) => {
  await thread.subscribe();
  await send(message.text, { thread });
});
bot.onSubscribedMessage(async (thread, message) => {
  await send(message.text, { thread });
});
```

Threading is handled by the [Chat SDK adapter](/docs/chat-sdk#how-threading-works).

**4. Configure webhooks**

Eve registers adapter endpoints at `/eve/v1/resend`. [Edit your webhook](/docs/webhooks/introduction) for `email.received` events to point to this endpoint.

## Configuration options

| Parameter | Type | Required | Description |
| - | - | - | - |
| `fromAddress` | `string` | Yes | Sender email address |
| `fromName` | `string` | No | Display name for the From header |
| `apiKey` | `string` | No | Resend API key. Falls back to `RESEND_API_KEY` env var |
| `webhookSecret` | `string` | No | Webhook signing secret. Falls back to `RESEND_WEBHOOK_SECRET` env var |


# Forward emails with Resend Inbound
Source: https://resend.com/docs/knowledge-base/forward-emails-with-resend-inbound

Learn how to forward receiving emails to another email address with Resend Inbound.

Inbound enables you to receive emails with Resend.

This guide demonstrates how to forward received emails using [NextJS](https://nextjs.org/), although you can use any framework you prefer.

**1. Verify a domain with Inbound**

[Verify a domain](https://resend.com/domains) and enable receiving emails for that domain. We strongly recommend verifying a subdomain (`subdomain.example.com`) instead of the root domain (`example.com`).

![Verify a domain with Inbound](https://mintcdn.com/resend/Pc2KlUXbYPa-UCHT/images/forward-emails-with-resend-inbound.png?fit=max\&auto=format\&n=Pc2KlUXbYPa-UCHT\&q=85\&s=bb522c39f8fc29fafeda1166be728cca)

Add the records in your DNS provider and wait for verification to finish in Resend. Learn more about [adding Domains in Resend](/docs/dashboard/domains/introduction).

> [!WARNING]
>
> When you enable Inbound on a domain, Resend receives *all emails* sent to that
> specific domain depending on the priority of the MX record. For this reason,
> we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
> of the root domain (`example.com`). Learn more about [avoiding conflicts with
> your existing MX
> records](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

**2. Create a POST route**

Resend can send a webhook to your application's endpoint every time you receive an email.

Add a new POST route to your application's endpoint.

```ts app/api/inbound-webhook/route.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';

export const POST = async (request: NextRequest) => {
  try {
    const payload = await request.text();

    return NextResponse.json(payload);
  } catch (error) {
    console.error(error);
    return new NextResponse(`Error: ${error}`, { status: 500 });
  }
};
```

**3. Create a webhook in Resend**

Go to the [Webhooks page](https://resend.com/webhooks) and click **Add Webhook**.

1. Add your publicly accessible HTTPS URL.
2. Select all events you want to observe (e.g., `email.received`).
3. Click **Add**.

![Create a webhook in Resend](https://mintcdn.com/resend/Pc2KlUXbYPa-UCHT/images/forward-emails-with-resend-inbound-1.png?fit=max\&auto=format\&n=Pc2KlUXbYPa-UCHT\&q=85\&s=43a04cb717556ed636109764863bf44a)

> [!TIP]
>
> For development, you can create a tunnel to your localhost server using a tool like
> [ngrok](https://ngrok.com/download) or [VS Code Port Forwarding](https://code.visualstudio.com/docs/debugtest/port-forwarding). These tools serve your local dev environment at a public URL you can use to test your local webhook endpoint.
>
> Example: `https://example123.ngrok.io/api/webhook`

**4. Add Resend to your project**

Add the Resend Node.js SDK to your project using your preferred package manager.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

Create an [API key with "Full access" permission](/docs/dashboard/api-keys/introduction) in Resend and add it to your project's .env file.

```env .env theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY=re_xxxxxxxxx
```

**5. Verify the webhook request**

Webhook signing secrets are used to validate the payload data sent to your application from Resend.

Update your POST route to verify the webhook request using the webhook secret. First, copy the webhook secret from the webhook details page.

![Webhook Secret](https://mintcdn.com/resend/Pc2KlUXbYPa-UCHT/images/forward-emails-with-resend-inbound-2.png?fit=max\&auto=format\&n=Pc2KlUXbYPa-UCHT\&q=85\&s=1f5b8a6ea354470d05869f61ffb087ec)

Then, add it to your project's .env file.

```env .env theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_WEBHOOK_SECRET=whsec_xxxxxxxxxx
```

Update the POST route to verify the webhook request using the webhook secret.

> [!TIP]
>
> Make sure that you’re using the raw request body when verifying webhooks. The cryptographic signature is sensitive to even the slightest change. Some frameworks parse the request as JSON and then stringify it, and this will also break the signature verification.

```ts app/api/inbound-webhook/route.ts {3, 5, 12-32} theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export async function POST(req: NextRequest) {
  try {
    // we need raw request text to verify the webhook
    const payload = await req.text();

    const id = req.headers.get('svix-id');
    const timestamp = req.headers.get('svix-timestamp');
    const signature = req.headers.get('svix-signature');

    if (!id || !timestamp || !signature) {
      return new NextResponse('Missing headers', { status: 400 });
    }

    // Throws an error if the webhook is invalid
    // Otherwise, returns the parsed payload object
    const result = resend.webhooks.verify({
      payload,
      headers: {
        id,
        timestamp,
        signature,
      },
      webhookSecret: process.env.RESEND_WEBHOOK_SECRET!,
    });

    return NextResponse.json(result);
  } catch (error) {
    console.error(error);
    return new NextResponse(`Error: ${error}`, { status: 500 });
  }
}
```

**6. Process incoming emails**

Once you verify the webhook, it returns the webhook payload as a JSON object. You can use this payload to forward the email to another email address. Note the following steps:

1. Add a guard clause to ensure the event type is `email.received`.
2. Get the incoming email's content
3. Download and encode any attachments
4. Forward the email (remember to update the `from` and `to` addresses below)

> [!NOTE]
>
> Webhooks do not include the email body, headers, or attachments, only their
> metadata. You must call the [Received emails
> API](/docs/api-reference/emails/retrieve-received-email) or the [Attachments
> API](/docs/api-reference/emails/list-received-email-attachments) to retrieve them.
> This design choice supports large attachments in serverless environments that
> have limited request body sizes.

```ts app/api/inbound-webhook/route.ts {29, 34, 42, 67} theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend, type ListAttachmentsResponseSuccess } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export async function POST(req: NextRequest) {
  try {
    const payload = await req.text();

    const id = req.headers.get('svix-id');
    const timestamp = req.headers.get('svix-timestamp');
    const signature = req.headers.get('svix-signature');

    if (!id || !timestamp || !signature) {
      return new NextResponse('Missing headers', { status: 400 });
    }

    const result = resend.webhooks.verify({
      payload,
      headers: {
        id,
        timestamp,
        signature,
      },
      webhookSecret: process.env.RESEND_WEBHOOK_SECRET!,
    });

    // 1. Add a guard clause to ensure the event type is `email.received`.
    if (result.type !== 'email.received') {
      return NextResponse.json({ message: 'Invalid event' }, { status: 200 });
    }

    // 2. Get the incoming email's content
    const { data: email, error: emailError } =
      await resend.emails.receiving.get(result.data.email_id);

    if (emailError) {
      throw new Error(`Failed to fetch email: ${emailError.message}`);
    }

    // 3. Download and encode any attachments
    const { data: attachmentsData, error: attachmentsError } =
      await resend.emails.receiving.attachments.list({
        emailId: result.data.email_id,
      });

    if (attachmentsError) {
      throw new Error(
        `Failed to fetch attachments: ${attachmentsError.message}`,
      );
    }

    const attachments =
      attachmentsData?.data as ListAttachmentsResponseSuccess['data'] &
        { content: string }[];

    if (attachments && attachments.length > 0) {
      // download the attachments and encode them in base64
      for (const attachment of attachments) {
        const response = await fetch(attachment.download_url);
        const buffer = Buffer.from(await response.arrayBuffer());
        attachment.content = buffer.toString('base64');
      }
    }

    // 4. Forward the email
    const { data, error: sendError } = await resend.emails.send({
      from: 'onboarding@resend.dev', // replace with an email address from your verified domain
      to: ['delivered@resend.dev'], // replace with the email address you want to forward the email to
      subject: result.data.subject,
      html: email.html,
      text: email.text,
      attachments,
    });

    if (sendError) {
      throw new Error(`Failed to forward email: ${sendError.message}`);
    }

    return NextResponse.json({ message: 'Email forwarded successfully', data });
  } catch (error) {
    console.error(error);
    return new NextResponse(`Error: ${error}`, { status: 500 });
  }
}
```

**7. Test the endpoint**

You can test the endpoint by sending an email to the domain you verified.

For example, if you verified `marketing.example.com`, send an email to `test@marketing.example.com`.

* Try a simple HTML email with a subject and a body.
* Try an email with an attachment or multiple attachments.

You can view the received email in the [Emails page](https://resend.com/emails/receiving) and see the webhook payload in the [Webhooks page](https://resend.com/webhooks).

**8. Go to Production**

Once you've tested the endpoint:

1. Publish your application to your production environment.
2. Add your production POST endpoint as a new webhook in Resend.


# Get Started with Resend and Supabase
Source: https://resend.com/docs/knowledge-base/getting-started-with-resend-and-supabase

A quick jumpstart to using Resend with Supabase.

This guide helps you get started with Resend by:

* [Setting up Resend](#set-up-resend)
* [Send Auth Emails with Resend](#send-auth-emails-with-resend)
* [Send Emails with Supabase Edge Functions](#send-emails-with-supabase-edge-functions)

## Set up Resend

To send emails with your Supabase project, you'll need to first verify it in Resend.

Go to [the Domains page](https://resend.com/domains) and click on **Add Domain**.

1. Add your domain name. We recommend [using a subdomain](/docs/dashboard/domains/introduction#subdomains) like `updates.example.com` instead of the root domain.
2. Add the DNS records to your DNS provider ([learn more about these records](/docs/dashboard/domains/introduction)).

   ![Resend Domains page](https://mintcdn.com/resend/_kGPo-rF0-rO9nI4/images/resend-domain-records.png?fit=max\&auto=format\&n=_kGPo-rF0-rO9nI4\&q=85\&s=24107151c9a59db661aca80c64338bfe)
3. Click on **Verify DNS Records** to begin the verification process.
4. Wait for the verification to complete (usually takes 5–10 minutes)

> [!NOTE]
>
> Resend requires you own your domain (i.e., not a shared or public domain).
> Adding DNS records gives Resend the authority to send emails on your behalf
> and signals to the inbox providers that you're a legitimate sender.

## Send Auth Emails with Resend

If you want to use Resend to send your Supabase Auth Emails, you have three options:

1. [Using the Resend Integration](#send-with-the-resend-integration): simplest, but less customizable email templates.
2. [Custom Auth Functions](#send-with-custom-auth-functions): more customizable email templates, but requires more setup.
3. [Self-hosted with custom SMTP](#send-with-custom-smtp-server-for-self-hosting): only for those self-hosting Supabase.

### Send with the Resend Integration

Resend includes a pre-built integration with Supabase. Connecting Resend as your email provider will allow you to send your Supabase emails (for example, password resets and email confirmations) through Resend.

[YouTube video player](https://www.youtube.com/embed/BkfDsGMgutk)

1. Open the [Resend Integrations settings](https://resend.com/settings/integrations).
2. Click **Connect to Supabase** and login to your Supabase account if prompted.

   ![Resend Integrations settings](https://mintcdn.com/resend/_kGPo-rF0-rO9nI4/images/resend-integrations-settings.png?fit=max\&auto=format\&n=_kGPo-rF0-rO9nI4\&q=85\&s=b954067bfb28d84f7d8201e05a449815)
3. Select a project and click **Select Project**, then select your domain and click **Add API Key**. Resend will create an API key for you. Add a sender name and click **Configure SMTP Integration**.

   ![Resend Integrations settings](https://mintcdn.com/resend/_kGPo-rF0-rO9nI4/images/resend-supabase-setup-smtp.png?fit=max\&auto=format\&n=_kGPo-rF0-rO9nI4\&q=85\&s=e744247952bc105d6083babcc315b0a6)

Click on **Supabase Dashboard** to confirm the integration.

![Resend Integrations settings](https://mintcdn.com/resend/_kGPo-rF0-rO9nI4/images/resend-supabase-setup-confirm.png?fit=max\&auto=format\&n=_kGPo-rF0-rO9nI4\&q=85\&s=d72c13ba50f60530587107b6d7040223)

> [!NOTE]
>
> Supabase has a rate limit on the number of emails you can send per hour and
> requires you to [connect a custom email provider for more than 2
> emails/hour](https://supabase.com/docs/guides/auth/rate-limits). Once you set
> Resend as your email provider, you can send additional emails (by default, 25
> emails/hour, although you can change the rate limit in your project's
> [authentication
> settings](https://supabase.com/docs/guides/deployment/going-into-prod#rate-limiting-resource-allocation--abuse-prevention)).

### Send with custom auth functions

Benefit of using custom auth functions:

* More control over the email sending process since you control the sending function.
* More control over the email template using React Email or Resend Templates.

Note that this requires enabling [Supabase Auth Hooks](https://supabase.com/docs/guides/auth/auth-hooks).

[YouTube video player](https://www.youtube.com/embed/tB_HcKjW8fQ)

> [card] [Supabase Auth Hooks with Resend Templates](https://github.com/resend/supabase-auth-hooks-with-resend-templates)
>
> See the full source code.

### Send with a custom SMTP server for self-hosting

If you're self-hosting Supabase, you can use a custom SMTP server to send your emails. [Learn more here](/docs/send-with-smtp).

## Send Emails with Supabase Edge Functions

If you're using Supabase Edge Functions, you can add email sending to your function by using the Resend Node.js SDK. You can use these functions for Auth Emails ([as shown above](#custom-auth-functions)) or for other emails (for example, app notifications and account activity).

First, make sure you have the latest version of the [Supabase CLI](https://supabase.com/docs/guides/cli#installation) installed.

**1. Create Supabase function**

Create a new function locally:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
supabase functions new resend
```

**2. Edit the handler function**

Paste the following code into the `index.ts` file:

```js index.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { serve } from "https://deno.land/std@0.168.0/http/server.ts";

const RESEND_API_KEY = 're_xxxxxxxxx';

const handler = async (_request: Request): Promise<Response> => {
    const res = await fetch('https://api.resend.com/emails', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${RESEND_API_KEY}`
        },
        body: JSON.stringify({
            from: 'Acme <onboarding@resend.dev>',
            to: ['delivered@resend.dev'],
            subject: 'hello world',
            html: '<strong>it works!</strong>',
        })
    });

    const data = await res.json();

    return new Response(JSON.stringify(data), {
        status: 200,
        headers: {
            'Content-Type': 'application/json',
        },
    });
};

serve(handler);
```

**3. Deploy and send email**

Run function locally:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
supabase functions start
supabase functions serve resend --no-verify-jwt
```

Deploy function to Supabase:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
supabase functions deploy resend
```

Open the endpoint URL to send an email:

![Supabase Edge Functions - Deploy Function](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/supabase-edge-functions-deploy-function.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=e28cab375d10a57f712e77ff3c888005)

## Examples

> [card] [Supabase Edge Functions Example](https://github.com/resend/resend-supabase-edge-functions-example)
>
> See the full source code.

## Get more help

If you have any questions, please let us know at [support@resend.com](mailto:support@resend.com).


# How to add multi-factor authentication to your Resend account
Source: https://resend.com/docs/knowledge-base/how-can-i-add-mfa

How to enable and disable multi-factor authentication (MFA) or two-factor authentication (2FA) on your Resend account, save your recovery code, and what to do if you lose your device.

Multi-factor authentication (MFA), also called two-factor authentication (2FA), adds an extra layer of security by requiring a second verification factor when you sign in.

## Enable MFA

To enable MFA on your Resend account:

1. Navigate to your [**Profile**](https://resend.com/profile) page.
2. Click **Enable MFA**.
3. Scan the QR code with your preferred authenticator app.
4. Enter the code provided by the authenticator app.
5. Copy the recovery code Resend shows you, store it, and click **I've saved my recovery code**.

Once MFA is enabled, you'll be asked for a code from your authenticator app whenever you sign in.

## Save your recovery code

If you lose access to your authenticator app, your recovery code turns off MFA so you can sign in and set it up again. The code works once, and Resend shows it only when you turn on MFA. Store it somewhere other than the device that holds your authenticator app, such as a password manager.

If you turned on MFA before recovery codes were introduced on 8 October 2026, your account has no recovery code yet. Generate one from your [**Profile**](https://resend.com/profile) page while you can still sign in.

## Disable MFA

To disable MFA on your Resend account:

1. Navigate to your [**Profile**](https://resend.com/profile) page.
2. Click **Revoke Access**.

After revoking access, you can sign in with your email and password without an authenticator code.

## If you change or lose your device

* **Changing phones:** while you can still sign in, click **Revoke Access** on your [**Profile**](https://resend.com/profile) page, then click **Enable MFA**, scan the new QR code with the authenticator app on your new device, and save the new recovery code.
* **Codes rejected:** use the entry your authenticator app created for Resend, not an entry for another service, and set your phone's clock to update automatically.
* **Device lost:** enter your recovery code when Resend asks for your authenticator code. MFA is turned off, you are signed in, and you can turn MFA on again with your new device. Without a recovery code, a password reset does not remove MFA, and another team member, including an admin, cannot reset it for you. Resend support can remove MFA after verifying that you own a domain on the account. See [Locked out by MFA: lost authenticator device](/docs/guides/account/locked-out-by-mfa) for the steps.

## MFA for your team

MFA is enabled per account, not per team. There is no setting to require or enforce MFA for everyone on your team. Each member enables it individually on their own [**Profile**](https://resend.com/profile) page.

Every member of the team can check who has enabled MFA from the [**Team Settings**](https://resend.com/settings/team) page. The **Enabled MFA** column is not admin-only. See [Managing Teams](/docs/dashboard/settings/team) for details.


# How to change your Resend email address
Source: https://resend.com/docs/knowledge-base/how-can-i-change-my-email-address

How to change the email address associated with your Resend account.

> [!NOTE]
>
> If you signed up with Google or GitHub, you can't change your account's email
> address on the Profile page. Instead, [invite the new email address as a team
> member](/docs/dashboard/settings/team) with the Admin role. Once the new user can
> sign in, you can remove the old user from the team. Your API keys, domains,
> and settings stay with the team.

To change the email address associated with your Resend account:

1. Navigate to your [**Profile**](https://resend.com/profile) page.
2. Under **Your email**, enter your new email address in the **Email address** field.
3. Click the **Update email** button.

After clicking **Update email**, you will be signed out and two confirmation emails will be sent:

* **To your new email address**: An email with the subject "Confirm email change for Resend" asking you to confirm the update.
* **To your current email address**: An email with the subject "Request to change your email" asking you to confirm the request.

Click the confirmation link in both emails to complete the email change. Once both confirmations are complete, you can log in with your new email address.


# How to delete your Resend account
Source: https://resend.com/docs/knowledge-base/how-can-i-delete-my-resend-account

How to request your Resend account and data to be deleted.

To delete your Resend account, navigate to your [Profile Settings](https://resend.com/profile) and scroll to the **Delete account** section.

If you're associated with any teams, you'll be automatically prompted to leave or delete them before you can delete your account. Once all teams are removed, you can proceed with account deletion.

After confirmation, your account and all associated data will be queued for permanent deletion.

> [!WARNING]
>
> This action is not reversible, so please proceed with caution.

## Understanding Accounts vs Teams

A **Resend Account** is your login method (email address) used to access Resend. A **Resend Team** is the environment where your API keys, domains, and email data are stored.

* You can only have one Account, but you can be part of multiple Teams
* To delete your Account, you must first leave or delete all Teams you're associated with

## Deleting a Team

If you want to delete a team (rather than leaving it), see [How to delete your Resend team](/docs/knowledge-base/how-can-i-delete-my-team).


# How to delete your Resend team
Source: https://resend.com/docs/knowledge-base/how-can-i-delete-my-team

How to request your Resend team and team data to be deleted.

To request your Resend team and team data to be deleted:

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Select the **Delete Team** button.

Upon confirmation, Resend will delete your team and all your team data.

> [!NOTE]
>
> If you are the last member of a team, you can also delete it by selecting
> **Leave Team** instead. The system will automatically delete the team when the
> last member leaves.

> [!WARNING]
>
> Please note that this action is not reversible, so please proceed with
> caution.


# Can You Receive Emails with Resend?
Source: https://resend.com/docs/knowledge-base/how-can-i-receive-emails-with-resend

Receive emails with webhooks and process content, attachments, forwarding, and replies.

Yes. Resend supports receiving emails (inbound) via webhooks.

With Receiving, you can:

* Receive incoming emails and get notified with the `email.received` webhook event.
* Retrieve full email content (HTML, text, headers) using the Receiving API.
* Process attachments using attachment metadata and temporary download URLs.

You can receive emails at:

* A Resend-managed `*.resend.app` receiving domain, or
* Your own custom domain by adding the required `MX` record.

See the full guide: [Receiving Emails](/docs/dashboard/receiving/introduction).


# Sender email addresses in Resend
Source: https://resend.com/docs/knowledge-base/how-do-I-create-an-email-address-or-sender-in-resend

Learn how sending from an email address works on Resend.

Resend does not require you to “create an email address”, “set up a sender identity”, or “add a from-address” before sending.

Once a domain is verified in your Resend account, you can send from any email address at that domain.

> [!NOTE]
>
> The email address you send from does not need to exist in another system.
> However, we recommend using addresses that can receive replies.

## How to add the sender address

You add the sender address in the `from` field when you send the email.

To include a friendly name, use the format `"Your Name <sender@example.com>"`.

```ts Node.js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@example.com>',
  to: ['customer@example.com'],
  subject: 'Welcome to Acme',
  html: '<p>Thanks for signing up!</p>',
});
```

```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}}
$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@example.com>',
  'to' => ['customer@example.com'],
  'subject' => 'Welcome to Acme',
  'html' => '<p>Thanks for signing up!</p>'
]);
```

```python Python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend

resend.api_key = "re_xxxxxxxxx"

params: resend.Emails.SendParams = {
  "from": "Acme <onboarding@example.com>",
  "to": ["customer@example.com"],
  "subject": "Welcome to Acme",
  "html": "<p>Thanks for signing up!</p>"
}

email = resend.Emails.send(params)
print(email)
```

```rb Ruby theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@example.com>",
  "to": ["customer@example.com"],
  "subject": "Welcome to Acme",
  "html": "<p>Thanks for signing up!</p>"
}

sent = Resend::Emails.send(params)
puts sent
```

```go Go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"context"
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.SendEmailRequest{
      From:    "Acme <onboarding@example.com>",
      To:      []string{"customer@example.com"},
      Subject: "Welcome to Acme",
      Html:    "<p>Thanks for signing up!</p>",
  }

  sent, err := client.Emails.SendWithContext(ctx, params)

  if err != nil {
    panic(err)
  }
  fmt.Println(sent.Id)
}
```

```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@example.com>";
  let to = ["customer@example.com"];
  let subject = "Welcome to Acme";
  let html = "<p>Thanks for signing up!</p>";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html(html);

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```java Java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;

public class Main {
    public static void main(String[] args) {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@example.com>")
                .to("customer@example.com")
                .subject("Welcome to Acme")
                .html("<p>Thanks for signing up!</p>")
                .build();

        CreateEmailResponse data = resend.emails().send(params);
    }
}
```

```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI

var resp = await resend.EmailSendAsync( new EmailMessage()
{
    From = "Acme <onboarding@example.com>",
    To = "customer@example.com",
    Subject = "Welcome to Acme",
    HtmlBody = "<p>Thanks for signing up!</p>",
} );
Console.WriteLine( "Email Id={0}", resp.Content );
```

```bash cURL theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST 'https://api.resend.com/emails' \
     -H 'Authorization: Bearer re_xxxxxxxxx' \
     -H 'Content-Type: application/json' \
     -d $'{
  "from": "Acme <onboarding@example.com>",
  "to": ["customer@example.com"],
  "subject": "Welcome to Acme",
  "html": "<p>Thanks for signing up!</p>"
}'
```

```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
resend emails send \
  --from "Acme <onboarding@example.com>" \
  --to customer@example.com \
  --subject "Welcome to Acme" \
  --html "<p>Thanks for signing up!</p>"
```

In this example, `onboarding@example.com` is the sender address. As long as `example.com` is verified in Resend, you can use that address in `from` without creating it first.

## Common misconceptions

Some platforms require you to create, register, or pre-approve a sending address.\
Resend does not. After verifying your domain, you’re free to send from any address at that domain, such as `notifications@example.com` or `updates@example.com`. No extra setup, creation, or configuration of that address is needed.

## Getting started

To start sending emails with Resend:

1. [Sign up for a Resend account](https://resend.com/signup)
2. [Add and verify your domain](https://resend.com/domains)
3. [Create an API key](https://resend.com/api-keys)
4. Start sending emails immediately from any address at the domain you verified

If you're having trouble with domain verification or DNS records, see our [domain verification troubleshooting guide](/docs/knowledge-base/what-if-my-domain-is-not-verifying) or check our [DNS setup guides](/docs/knowledge-base/introduction) for your specific DNS provider.


# How do Dedicated IPs work?
Source: https://resend.com/docs/knowledge-base/how-do-dedicated-ips-work

When are Dedicated IPs helpful, and how can they be requested.

## What is a Dedicated IP?

In email delivery, the sending IP address serves as a key identifier. Inbox Providers like Gmail track the reputation of these IPs based on the quality and quantity of emails sent from them, factoring this information into filtering and inbox placement decisions.

By default, all Resend users use our shared IPs, which are a collection of IPs shared across many senders. Optionally, you can purchase a dedicated IP pool so a range of IPs are exclusively assigned to your sending.

Resend goes one step further and exclusively provisions "Managed Dedicated IP Pools". These managed pools handle multiple delicate and time consuming aspects of dedicated IPs:

* **Automatic warmup**: New IPs have no reputation and are therefore under scrutiny by inbox providers. Resend carefully migrates your sending over from the shared pool to your dedicated pool.
* **Automatic scaling**: IPs can only send at a certain rate based on the specifications of each inbox provider. Resend scales your pool dynamically based on the inbox provider feedback, without you lifting a finger.
* **Continuous monitoring**: Resend continuously monitors the reputation and performance of your dedicated IPs.
* **Fully dedicated**: You can segregate your emails from sending on shared pools to reduce risk of "noisy neighbors".

> [!NOTE]
>
> Resend only provisions Managed Dedicated IP Pools, but we will refer to them
> as **Dedicated IPs** in this article to be succinct.

## When Dedicated IPs are helpful

Historically, Dedicated IPs were seen as the primary ingredient to great deliverability. This is not true anymore as Inbox Providers have incorporated dozens of other factors like sending history, domain reputation, and sending feedback (bounces and complaints) more predominantly than IP reputation.

Though Dedicated IPs are not a deliverability silver bullet, they maintain a helpful benefit: **removing risk of noisy neighbors**.

There is power in numbers, and for many senders it can be helpful to leverage the positive reputation of other senders in an IP pool. For some senders though, they want to maintain their own IP reputation without any chance of being impacted, positively or negatively, by other senders. For them, Dedicated IPs are a helpful solution.

## When Dedicated IPs are not helpful

Dedicated IPs can be helpful, but there are some situations where they can actually hinder your ability to reach the inbox. If any of these situations match your use case, Dedicated IPs may hinder more than help:

* **Low email volume**: Sending less than 90,000 emails a month may not be enough to keep the IPs warm.
* **Inconsistent sending**: Sudden changes in email volume can hurt your IP reputation.
* **Poor email practices**: A Dedicated IP exposes your sending behavior even more.
* **New sender**: If you're starting out and have no sending history.
* **IP Allowlisting**: Resend does not expose the IPs included in your dedicated pool.

## How IP warmup works

With Resend's Managed Dedicated IP Pools, the warmup process is handled automatically:

1. **Automatic scaling**: Add or remove IP addresses based on your sending volume.
2. **Gradual increase**: Gradually increase the volume of emails sent through new IPs over time.
3. **Traffic distribution**: During warmup, traffic is distributed across shared and dedicated IPs.
4. **Reputation monitoring**: Continuously monitor the reputation of your dedicated IPs.
5. **Adaptive warmup**: Adapt the warmup process to your sending patterns.

Often IP warmup is a highly manual process and requires great care if you don't want a deliverability degradation in the process. With this automatic warmup process, that's handled for you so you can focus on sending.

> [!NOTE]
>
> Because Managed Dedicated IP Pools are dynamically scaled, **we do not expose
> the list of IPs** in your dedicated pool.

## Requirements for a Dedicated IP

You can request a Dedicated IP if you meet the following requirements:

* Your domains are in the same region (Dedicated IPs are provisioned per region).
* Your sending volume exceeds 3,000 emails sent per day.
* You already have an active Transactional Scale or Marketing Pro subscription.
* All domains you want added to the Dedicated IP are already verified on Resend.

## How to request a Dedicated IP

If you're on a Scale plan or higher, you can request a Dedicated IP directly from your dashboard:

1. Navigate to **Settings** > **Usage**
2. Click **Request dedicated IP** in the Dedicated IPs section
3. Fill out the request form with information about your sending patterns

Alternatively, you can request a Dedicated IP by [chatting with support](https://resend.com/help).

You will need to provide the following information:

* What types of emails are you sending?
* How many emails are you sending per day and month on average?
* Is your sending consistent every day, or do you send in bursts?
* Which domains do you want included in your Dedicated IP?


# How to avoid conflicts with your MX records
Source: https://resend.com/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records

Learn how to avoid conflicts with your existing MX records when setting up a Resend domain.

## MX records for sending and receiving emails

MX (Mail Exchanger) records specify where incoming mail is delivered on behalf of a domain. Every MX value has a unique priority (also known as preference) value. The lower the number, the higher the priority.

Resend may require that you setup a MX record on two occasions:

1. **[Enabling your domain to send emails](https://resend.com/docs/dashboard/emails/introduction)**: You need to setup an MX record on `send.example.com` to establish a return-path for bounce/complaint reports from Inbox Providers. This return path is set in the email headers of every email you send through Resend.

> [!NOTE]
>
> For domains created after August 2026, Resend may generate CNAME records for sending instead of the MX and TXT pair, in which case this occasion doesn't apply to your domain. Always add the exact records shown in your domain's **Records** tab within the Resend dashboard.
>
> Note that a CNAME record cannot co-exist with any other record on the same subdomain, so if you already have other records set for `send.example.com`, you will need to either configure a different `Return-Path` subdomain (e.g. `bounce.example.com`) or remove the existing records for `send.example.com`.

2. **[Enabling your domain to receive emails](https://resend.com/docs/dashboard/receiving/custom-domains)**: You can setup an MX record on your domain to route all received emails to Resend.

## Avoiding conflicts with MX record priorities

Here's an example for each occasion Resend requires you to setup a MX record.

Say you're using G Suite for your email. You'll have an MX record that looks something like this:

```
example.com     MX    10 alt3.aspmx.l.google.com.
```

This record specifies that any incoming mail to `<anything>@example.com` is delivered to the Google servers.

Now, say you want to use Resend to send emails from `@example.com`. You'll need to add an MX record for `send.example.com` that looks something like this:

```
send.example.com     MX    10 feedback-smtp.us-east-1.amazonses.com
```

This **won't** conflict because the MX record is for `send.example.com`, not `example.com`. MX records only impact the subdomain they are associated to, so the Resend MX record will not affect your existing records on the root domain.

Now say you want to start receiving emails through Resend.

Because you already have the MX record `example.com`, you have two options:

1. **\[Recommended] Create a MX record for a subdomain** (e.g. `subdomain.example.com`). Now emails sent to `<anything>@example.com` will continue going to G Suite, and emails sent to `<anything>@subdomain.domain.com` will go to Resend.

2. **Create a MX record with the lowest priority** among the other MX record for your domain.
   Since on our example, you already had a MX record for `example.com` point to G Suite, you would create:

```
example.com    MX    9  inbound-smtp.us-east-1.amazonaws.com
```

Now this MX record priority has a lower value (higher priority) so it will be prioritized. But keep in mind that:

> [!NOTE]
>
> * This will route all emails destined to `<anything>@example.com` to Resend, instead of your previous provider (e.g., G Suite).
> * If two MX records have the same priority value, this does not mean it will send to both servers. Instead, only one server will be chosen, randomly, per email delivery attempt.

## Solving common conflicts

> [accordion] Conflicts with existing records
>
> If you already have a MX record set for `send.example.com`, you will need to remove it before adding the Resend MX record.
>
> If you need to keep the existing record, you can add a subdomain to your domain (e.g. `sub.example.com`) which will move the Resend MX location to `send.sub.example.com`.

> [accordion] Conflicts with existing priority
>
> Each MX should have a unique priority value. We suggest using 10 for your MX record on `send.example.com`, but you can use a lower number (higher priority) if 10 is already in use.
>
> > [!NOTE]
> >
> > The lowest possible value (highest priority) is 0. So if you already have a record with this priority, you'll need to remove it in order to create the MX record for Resend.


# How to cancel a Broadcast
Source: https://resend.com/docs/knowledge-base/how-do-i-cancel-a-broadcast

Cancel a scheduled Broadcast or stop one that is still sending.

You can cancel a Broadcast that is scheduled or still sending. When you cancel a Broadcast, here's what happens based on its status:

* `scheduled` → `draft`: no emails are sent. You can update the Broadcast and reschedule it to be sent.
* `queued` → `canceled`: emails that have already been sent are not affected, but any emails still in the queue will no longer be sent.

## Cancel a Broadcast

1. Go to [Broadcasts](https://resend.com/broadcasts) and open the scheduled or sending Broadcast.
2. Click **Cancel** on the Broadcast page.

Resend then returns a scheduled Broadcast to `draft`, or halts delivery to the remaining recipients if the Broadcast is sending.

You can also [cancel a Broadcast via the API](/docs/api-reference/broadcasts/cancel-broadcast).

> [!NOTE]
>
> Canceling is only available while a Broadcast is `scheduled` or `queued`.
> Emails that have already been sent cannot be recalled.

## Related pages

* [Managing Broadcasts](/docs/dashboard/broadcasts/introduction)
* [Broadcast statuses](/docs/dashboard/broadcasts/manage-broadcasts#understand-broadcast-statuses)


# How to ensure sensitive data isn't stored on Resend
Source: https://resend.com/docs/knowledge-base/how-do-i-ensure-sensitive-data-isnt-stored-on-resend

Information on how you can protect your customer's information.

Resend can turn off message content storage for teams with additional compliance requirements. This is available to customers who meet the following criteria:

1. The team has been a Resend Pro or Scale subscriber for at least 1 month.
2. The team is sending from a domain with an active website.
3. The team has sent over 3,000 emails with a \< 5% bounce rate.

This feature requires a \$50/mo add-on. If your account meets these requirements and you would like this turned on, contact our support team for help.


# How to fix CORS issues
Source: https://resend.com/docs/knowledge-base/how-do-i-fix-cors-issues

Information on recommended options to avoid CORS errors when sending emails.

## Problem

It's common for people to hit CORS (Cross-Origin Resource Sharing) issues when using the Resend API. This error typically shows as:

```
Access to XMLHttpRequest at 'https://api.resend.com/emails'
from origin 'http://localhost:3000' has been blocked by CORS policy:
Response to preflight request doesn't pass access control check:
No 'Access-Control-Allow-Origin' header is present on the requested resource.
```

## Solution

Usually CORS errors happens when you're sending emails from the **client-side**.

Send the emails on the **server-side** to not expose your API keys and avoid CORS issues.


# How to maximize deliverability for Supabase Auth emails
Source: https://resend.com/docs/knowledge-base/how-do-i-maximize-deliverability-for-supabase-auth-emails

Everything to do before you start sending authentication emails with Resend and Supabase.

> [!NOTE]
>
> If you haven't yet, [configure your own Supabase
> integration](https://resend.com/settings/integrations)!

Below are **five steps to improve the deliverability of your authentication emails**.

Prefer watching a video? Check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/51vzcGEmjRI)

## Setup a custom domain on Supabase

By default, Supabase generates a `supabase.co` domain for your project, and uses that domain for the links in your authentication emails (e.g., verify email, reset password).

Once you are ready to go live, though, it is important to setup a custom domain. The key benefit here is to align the domains used in your `from` address and the links in your emails. Especially for something as sensitive as email verification and magic links, **giving confidence to the inbox providers that the origin of the email and the links in the body are the same** can be impactful.

This changes your links from:

```
https://039357829384.supabase.co/auth/v1/{code}
```

To something like this:

```
https://auth.example.com/auth/v1/{code}
```

Supabase has a helpful guide for [Setting up a custom domain](https://supabase.com/docs/guides/platform/custom-domains).

## Setup a dedicated subdomain

There are many benefits to using a subdomain vs your root domain for sending, one being that you can isolate the reputation of the subdomain from your root domain.

For authentication emails, using a subdomain is particularly helpful because it is a way to **signal your intention to the inbox provider**. For example, if you use `auth.example.com` for your authentication emails, you are communicating to the inbox provider that all emails from this subdomain are related to sending authentication emails.

This clarity is essential because it helps the inbox provider understand that this subdomain is not used for sending marketing emails, which are more likely to be marked as spam.

> [!NOTE]
>
> If you don't want a subdomain just for auth, you can also achieve this by
> establishing one subdomain for all your transactional emails (e.g.,
> `notifications.example.com`).

To add a subdomain to Resend, you can [add it as a domain on the dashboard](https://resend.com/domains).

![Create auth subdomain](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/kb-create-auth-subdomain.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=3d0629c74757298069867f0019e69a90)

## Disable link and open tracking

Link and open tracking can be great for marketing emails but not for transactional emails. This kind of **tracking can actually hurt your deliverability**. Open tracking embeds a 1x1 pixel image in the email, and link tracking rewrites the links in the email to point to Resend's servers first. Both types can be seen as suspicious by the inbox provider and hurt your deliverability.

Also, Supabase has noted that link tracking is [known for corrupting verification links](https://supabase.com/docs/guides/platform/going-into-prod), making them unusable for your users.

You can disable link and open tracking by clicking on your domain and disabling at the bottom.

![Disable link and open tracking](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/kb-disable-tracking.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=1deeae548895ad4047ca7283faad95c6)

## Prepare for link scanners

Some inbox providers or enterprise systems have email scanners that run a `GET` request on all links in the body of the email. This type of scan can be problematic since Supabase Auth links are single-use.

To get around this problem, consider altering the email template to replace the original magic link with a link to a domain you control. The domain can present the user with a "Sign-in" button, which redirects the user to the original magic link URL when clicked.

## Setup DMARC

Like our human relationships, email deliverability is built on trust. The more inboxes can trust your emails, your domain, and your sending, the more likely your emails will be delivered to the inbox. This makes [Email Authentication a critical pillar](https://resend.com/blog/email-authentication-a-developers-guide) in the journey to excellent deliverability.

That is where DMARC comes in. As the industry standard for email authentication, **DMARC is a way to tell the inbox provider that you are who you say you are**. It is a way to signal to the inbox provider that you are a legitimate sender and that your emails should be delivered to the inbox.

Following security best practices like DMARC will show your validity and authenticity.

![DMARC policy details](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/kb-dmarc.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=2b853e7501c2863ddd2ded6de271e0b6)

You can use our [DMARC setup guide to get started](/docs/dashboard/domains/dmarc).


# How to send with an avatar
Source: https://resend.com/docs/knowledge-base/how-do-i-send-with-an-avatar

Learn how to show your avatar in the inbox of your recipients.

[Recent studies](https://www.businesswire.com/news/home/20210720005361/en/Red-Sift-and-Entrust-Survey-Showing-a-Logo-Positively-Affects-Consumer-Interaction-With-Emails-Open-Rates-Buying-Behavior-Brand-Recall-and-Confidence) are showing meaningful benefits of displaying your logo in the inbox:

* Increases brand recall by 18%.
* Improves open rate by 21%.
* Boosts purchase likelihood by 34%.
* Reinforces confidence in email by 90%.

![Email with an avatar](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/sender-avatar.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=af9242870f3967aaed057cb3f5f44c20)

## Gmail

Follow these steps to add an avatar to your Gmail inbox:

1. Go to your [Google Account Settings](https://myaccount.google.com/personal-info)
2. Upload a profile picture

Avatars in Gmail only display in the mobile app (including in push notifications) and inside opened emails on desktop.

## Outlook

Follow these steps to add an avatar to your Outlook inbox:

1. Go to your [Outlook Profile Settings](https://account.microsoft.com/profile/)
2. Upload a profile picture

Avatars in Outlook only display in the mobile app and inside opened emails on desktop.

## Yahoo

Follow these steps to add an avatar to your Yahoo inbox:

1. Go to your [Yahoo Account Setting](https://login.yahoo.com/account/personalinfo)
2. Upload a profile picture

Avatars in Yahoo only display in the mobile app and inside an opened email on desktop.

## Apple Mail

Apple Mail only shows avatars if recipients have added images to contacts. Alternatively, you can set up [Apple Branded Mail](/docs/knowledge-base/how-do-i-set-up-apple-branded-mail), a proprietary Apple format introduced with iOS 18.2 that displays your logo as an avatar in the inbox of Apple Mail, or [set up BIMI](/docs/dashboard/domains/bimi#what-is-bimi) with a Verified Mark Certificate.

## Using Gravatar

Some inbox service providers or email clients (e.g. Thunderbird, Airmail, and Postbox) rely on [Gravatar](https://gravatar.com/) to display an image.

You can set up a free Gravatar account, add your avatar, and verify your addresses you're sending from to that account to have your avatar displayed.

## Limitations

Almost every email provider has its own way of adding a profile picture to an inbox.

This means **you can only**:

1. Add your avatar to a real inbox, limiting it only to that provider
2. Send mail from the same address that you set the avatar on

The way around this is [BIMI (Brand Indicators for Message Identification)](/docs/dashboard/domains/bimi). BIMI now supports Common Mark Certificates (CMC) in addition to Verified Mark Certificates (VMC), making it more accessible. It is supported by nearly all major providers and allows you to send from any address on that domain.

> [!NOTE]
>
> Need assistance setting up BIMI? [We can help](https://resend.com/help).


# How to set up Apple Branded Mail
Source: https://resend.com/docs/knowledge-base/how-do-i-set-up-apple-branded-mail

Learn how to implement Apple Branded Mail to display your logo in Apple Mail clients.

## Prerequisites

To get the most out of this guide, you will need to:

* [Create an Apple Business Connect account](https://www.apple.com/business/connect/)
* [Setup DMARC on your domain](/docs/dashboard/domains/dmarc)
* A company identification number for Apple to verify your company

Prefer watching a video? Check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/zLDRvWVPqxk)

## Why use Apple Branded Mail

Apple Branded Mail is a proprietary Apple format that displays your logo as an avatar in the inbox of Apple Mail. Displaying your logo can increase brand recognition and trust and improve engagement.

There are a few benefits of Apple Branded mail over BIMI:

* Since it's an Apple format, it does not require a certificate like [BIMI does](/docs/dashboard/domains/bimi).
* The image support is broader, supporting `.png`, `.heif`, and `.jpg` logos.

Since Apple Branded Mail works only with Apple Mail on new iOS, iPadOS, and macOS versions, your logo will not show in other mail clients or older versions of Apple Mail.

For this reason, follow all possible methods for adding your logo to your emails, including Apple Branded Mail, [our general guide](/docs/knowledge-base/how-do-i-send-with-an-avatar), and [BIMI](/docs/dashboard/domains/bimi) if it fits your needs.

## Implementing Apple Branded Mail

**1. Configure DMARC**

> [!NOTE]
>
> If you haven't set up DMARC yet, follow our [DMARC Setup
> Guide](/docs/dashboard/domains/dmarc).

To ensure your logo appears with Apple Branded Mail, set your DMARC policy to either `p=quarantine;` or `p=reject;`. This policy guarantees that your emails are authenticated and prevents others from spoofing your domain and sending emails with your logo.

Here's an overview of the required parameters:

| Parameter | Purpose | Required Value |
| - | - | - |
| `p` | Policy | `p=quarantine;` or `p=reject;` |
| `pct` | Percentage | `pct=100;` |

Here is an example of an adequate DMARC record:

```
"v=DMARC1; p=quarantine; pct=100; rua=mailto:dmarcreports@example.com"
```

As we mention in our [DMARC Setup Guide](/docs/dashboard/domains/dmarc), be sure to test your emails to make sure they are passing DMARC before changing your DMARC policy to `p=quarantine;` or `p=reject;`.

**2. Create an Apple Business Connect account**

Apple displays the logo you set in your Business Connect account. [Create an account](https://www.apple.com/business/connect/) if your company does not already have one. Make sure to use your company details when signing up.

**3. Add your company details**

Apple will prompt you to provide details like your company address and name.

**4. Add your brand details**

Once your company account is created, in Apple Business Connect, select the **Branded Mail** option in the left sidebar and provide details on your brand. Add details like the brand name and your brand website.

![Add your brand details](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/abm-step-4-add-brand-details-1.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=8348f2b44a70bfb6c4e065046a7443dd)

![Add your brand details](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/abm-step-4-add-brand-details-2.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=8ae25d711442f1f38620bd0aa1996fee)

**5. Add your logo**

Once you fill out the brand details, upload your logo. Apple requires the logo to be at least 1024 x 1024 px in a `.png`, `.heif`, or `.jpeg` format.

![Add your logo](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/abm-step-5-add-your-logo.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=325d6466f5c237cd8c478eba3ac746d5)

**6. Add your domain**

Confirm the domains or email addresses where you want your brand logo to appear.

You can register your logo for your root domain or a subdomain. If you don't set a specific logo for a subdomain, the root domain logo will automatically display for any email sent from your subdomains.

**7. Verify your company**

Apple requires details to confirm your company identity.

If you're in the United States, provide a Federal Taxpayer Identification Number. Other countries will use a local equivalent for this step. Apple also asks that you add a DNS record to verify DNS access.

**8. Verify with Apple**

After you submit all your information, Apple will verify your details. This process may take up to seven business days.

Once the logo is verified, Apple will send an email notification and note the verified status in Branded Mail. Your logo will start to display in compatible Apple Mail versions.

![Verified logo](https://mintcdn.com/resend/PWWYUiKcsGOVT_Rs/images/abm-step-8-verify-with-apple.png?fit=max\&auto=format\&n=PWWYUiKcsGOVT_Rs\&q=85\&s=bbf80629357b9a4df827d9911677b97d)

> [!TIP]
>
> See Apple's documentation on [Apple Branded
> Mail](https://support.apple.com/en-au/guide/apple-business-connect/abcb761b19d2/web)
> for any detailed questions on adding your logo.


# How to add more domains
Source: https://resend.com/docs/knowledge-base/how-to-add-more-domains

Increase your domain limit with the domains add-on.

Every Resend plan includes a set number of verified custom domains. If you need more, you can enable the **domains add-on** in **Settings** > **Usage**. The add-on adds 100 domains on top of the number included in your plan for \$20 per month.

Adding more domains is a common need for multi-tenant products that verify a domain per customer. See [Setting up Resend for Multi-Tenant Applications](/docs/knowledge-base/setting-up-resend-for-multi-tenants) for how to structure that.

## Check your current limit

Navigate to [**Settings** > **Usage**](https://resend.com/settings/usage). The Domains section shows how many domains your team is using and how many your plan allows.

The number of domains included in each plan is listed on the [pricing page](https://resend.com/pricing).

![The Add-ons section of the Resend pricing page, showing the domains add-on at \$20 per month](https://mintcdn.com/resend/4aoJCf3h0EWlfiV5/images/pricing-domains-add-on.png?fit=max\&auto=format\&n=4aoJCf3h0EWlfiV5\&q=85\&s=5741fdddf81323ba42f87b44fc50ec46)

## Add the domains add-on

1. Navigate to [**Settings** > **Usage**](https://resend.com/settings/usage)
2. Find **Domains** under **Add-ons**
3. Turn on the **Domains** toggle
4. Click **Confirm**

If your team doesn't have a payment method on file, you will be taken to checkout to confirm the purchase.

The add-on costs \$20 per month and applies immediately. Your next invoice includes a prorated charge for the remainder of the current billing cycle.

Once enabled, the add-on appears on your [**Settings** > **Billing**](https://resend.com/settings/billing) page as its own line item, and the 100 extra domains are reflected in the domain count on **Settings** > **Usage**.

> [!NOTE]
>
> The domains add-on is available on paid transactional plans, and only team
> admins can manage add-ons. On Enterprise plans, the domain limit is set in
> your contract, so [contact support](https://resend.com/help) to change it.

> [!NOTE]
>
> The add-on raises the number of domains you can add. It does not change your
> monthly email quota, your contact limit, or your rate limit. Those are set by
> your plan. See [account quotas and
> limits](/docs/knowledge-base/account-quotas-and-limits).

## Remove the domains add-on

You can remove the add-on from the same place: navigate to **Settings** > **Usage** and turn off the **Domains** toggle under **Add-ons**.

## Need more than 100 extra domains

There is no fixed ceiling on custom domains. If 100 extra domains aren't enough, [chat with support](https://resend.com/help) or email [support@resend.com](mailto:support@resend.com) with your use case and the number of domains you expect to verify.


# How to handle a leaked API key
Source: https://resend.com/docs/knowledge-base/how-to-handle-a-leaked-api-key

Learn what to do when a Resend API key is exposed or used without authorization.

An API key is the only credential needed to send through your account. Anyone holding a leaked key can send from any domain you've verified, spend your monthly quota, and damage the sending reputation you've built.

This guide covers how keys typically leak, what to do, how to review what was sent, and how to limit the damage next time.

## Identify how the key leaked

Replacing a key without closing the leak means the new key is exposed the same way. Common leak sources include:

* A key committed to a Git repository. Search the history rather than only the working tree, because a key stays in history after it's removed from the files.
* A public or forked repository, a Gist, or a continuous integration log that prints environment variables.
* A key bundled into client-side or mobile code, where anyone can read it out of the browser or the app package.
* A key pasted into a screenshot, a chat message, an issue tracker, or a third-party tool.
* A publicly reachable `.env` file or a framework left in debug mode on a production host.

## Delete the key first

Deleting a key revokes it right away. There's no separate revoke step, and no further requests can authenticate with it once it's gone.

1. Open the [**API keys** Dashboard page](https://resend.com/api-keys).
2. Find the key you believe was exposed, using the **last used** indicator to narrow it down.
3. Click the **More options** button, then **Remove API key**.
4. Create a replacement key and deploy it to your services.

> [!WARNING]
>
> Treat the old key as compromised. You can't view an API key after it's
> created, so a replacement is always a new key rather than a reissue of the old
> one.

If your services are still running on the exposed key, follow the [key rotation steps](/docs/knowledge-base/how-to-handle-api-keys#key-rotation) so you don't experience downtime while you swap it out.

## Review what was sent

Two Dashboard pages hold the record of what happened:

* The [**Logs**](https://resend.com/logs) page lists every API request made against your account. Filter by API key and by date range to isolate the window.
* The [**Emails**](https://resend.com/emails) page lists the messages themselves, so you can see recipients, subjects, and delivery outcomes.

Resend keeps 30 days of activity.

## What Resend logs and what it doesn't

Each log entry records the endpoint, the HTTP method, the response status, and the timestamp. It also holds the User-Agent and the full request and response bodies.

Resend doesn't retain the following, so it isn't available during an investigation:

* Source IP addresses for API or SMTP connections
* Autonomous System Number (ASN), internet service provider, or geographic data
* `HELO` or `EHLO` hostnames
* Transport Layer Security (TLS) connection metadata

There's no separate internal store beyond what the Logs page shows. What you can export is the complete record.

## Recover your sending reputation

Deleting the key stops the unauthorized sending. Inbox providers weigh recent activity most heavily.

Watch your [**Metrics**](https://resend.com/metrics) page over the following weeks. All accounts must stay under a **4%** bounce rate and a **0.08%** spam rate. A rate above either threshold may result in a temporary pause in sending.

Recipients who marked the unauthorized messages as spam are added to your suppression list. That's expected behavior, and it protects you from sending to them again.

## Reduce the damage next time

You can't prevent every leak, but you can limit what one costs you.

* **Give each service its own key.** Per-key logs then show you which integration was abused, and you can delete one key without disrupting the rest.
* **Prefer "Sending access" over "Full access."** Most applications only need to send, and a "Sending access" key can't read your contacts even if it leaks.
* **Delete keys you aren't using.** Resend flags keys unused for 30 or more days in the Dashboard.

For the full set of practices, see [API key security](/docs/knowledge-base/how-to-handle-api-keys).

## Get more help

If you've worked through the steps above and still have questions, contact [Resend support](https://resend.com/help) with:

1. The ID of the affected API key.
2. The window when the unauthorized activity took place.
3. What you've already done to contain it.


# How to handle API keys
Source: https://resend.com/docs/knowledge-base/how-to-handle-api-keys

Learn how to handle API keys securely.

## Best Practices

Handle your API keys securely. Don't share your API key with others or expose it in the browser or other client-side code.

Here are some general guidelines:

* Store API keys in environment variables.
* Never commit API keys to version control.
* Never hard-code API keys in your code or share them publicly.
* Rotate API keys regularly. If an API key hasn't been used in the last 30 days, consider deleting it to keep your account secure.

> [!NOTE]
>
> You can view an API key only once after you create it.

> [!WARNING]
>
> If a key has already been exposed or used without your authorization, see [how
> to handle a leaked API key](/docs/knowledge-base/how-to-handle-a-leaked-api-key).

## Key Rotation

Resend API keys don't expire automatically. Keys remain valid until you manually delete them. Resend includes no built-in expiration date or automatic rotation mechanism, but it's a good security practice to rotate keys regularly.

To rotate an API key:

1. **Create a new key** in the [**API keys** Dashboard page](https://resend.com/api-keys) or [via the API](/docs/api-reference/api-keys/create-api-key) with the same permission level and domain scope as the key you're replacing.
2. **Update your services** to use the new key. Deploy the change to all environments that reference the old key.
3. **Verify the new key is working** by [filtering by API key on the **Logs** Dashboard page](https://resend.com/logs) and checking for recent requests.
4. **Delete the old key** once you've confirmed the new key is active across all services.

> [!WARNING]
>
> Don't delete the old key before the new key is deployed everywhere. Both keys
> will work simultaneously, so ensure your new key is working before deleting
> your old key so you don't experience downtime during the transition. You can
> programmatically [create](/docs/api-reference/api-keys/create-api-key),
> [list](/docs/api-reference/api-keys/list-api-keys), and
> [delete](/docs/api-reference/api-keys/delete-api-key) API keys to rotate keys.

Rotate keys at least every 90 days, or immediately if you suspect a key has been compromised. Resend flags keys unused for 30 or more days in the Dashboard to help you identify keys to review or delete.

If you already know a key has leaked, delete it now rather than rotating it on a schedule. The steps to contain the incident are in [how to handle a leaked API key](/docs/knowledge-base/how-to-handle-a-leaked-api-key).


# Introduction
Source: https://resend.com/docs/knowledge-base/introduction

A collection of answers to frequently asked questions.

## Domains & Verification

> [card] [How do I avoid conflicts with my MX records?](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records)
>
> Add DNS records without conflicting with existing MX records.

> [card] [What if my domain is not verifying?](/docs/knowledge-base/what-if-my-domain-is-not-verifying)
>
> What to do when your domain isn't verifying.

## DNS Guides

Step-by-step instructions for verifying your domain with popular DNS providers.

> [card] [Cloudflare DNS Guide](/docs/guides/dns/cloudflare)

> [card] [Gandi DNS Guide](/docs/guides/dns/gandi)

> [card] [GoDaddy DNS Guide](/docs/guides/dns/godaddy)

> [card] [DreamHost DNS Guide](/docs/guides/dns/dreamhost)

> [card] [Hetzner DNS Guide](/docs/guides/dns/hetzner)

> [card] [Hostinger DNS Guide](/docs/guides/dns/hostinger)

> [card] [IONOS DNS Guide](/docs/guides/dns/ionos)

> [card] [Namecheap DNS Guide](/docs/guides/dns/namecheap)

> [card] [Porkbun DNS Guide](/docs/guides/dns/porkbun)

> [card] [Route 53 DNS Guide](/docs/guides/dns/route53)

> [card] [Squarespace DNS Guide](/docs/guides/dns/squarespace)

> [card] [Strato DNS Guide](/docs/guides/dns/strato)

> [card] [Vercel DNS Guide](/docs/guides/dns/vercel)

## Deliverability

> [card] [How do I avoid Gmail's spam folder?](https://resend.com/guides/email/deliverability/avoid-gmail-spam-folder)
>
> Learn how to improve inbox placement in Gmail.

> [card] [Why Are My Emails Going to Spam?](https://resend.com/guides/email/deliverability/why-emails-go-to-spam)
>
> Troubleshoot emails landing in spam or getting quarantined.

> [card] [Why are my emails landing on the suppression list?](/docs/knowledge-base/why-are-my-emails-landing-on-the-suppression-list)
>
> Learn why your emails land on the suppression list, and how to remove them.

> [card] [Domain and IP Warm-up Guide](/docs/knowledge-base/warming-up)
>
> Learn how to warm up your domain and dedicated IP for optimal deliverability.

## Sending

> [card] [Account Quotas and Limits](/docs/knowledge-base/account-quotas-and-limits)
>
> Understand the sending quotas and rate limits for your Resend account.

> [card] [How do Dedicated IPs Work?](/docs/knowledge-base/how-do-dedicated-ips-work)
>
> Learn how Dedicated IPs work and how to request them.

> [card] [What sending feature should I use?](/docs/knowledge-base/what-sending-feature-to-use)
>
> Find the right Resend feature for your email sending use case.

> [card] [Should I add an unsubscribe link?](/docs/knowledge-base/should-i-add-an-unsubscribe-link)
>
> Learn when to add unsubscribe links to your transactional and marketing
> emails.

## Inboxes

> [card] [Build a support inbox from a contact form](/docs/guides/inboxes/build-a-support-inbox)
>
> Send contact form submissions to an inbox that the agent labels and drafts
> replies for.

## Tutorials

> [card] [Maximize deliverability for Supabase Auth emails](/docs/knowledge-base/how-do-i-maximize-deliverability-for-supabase-auth-emails)
>
> Everything you should do before sending authentication emails with Resend and
> Supabase.

> [card] [How do I set up Apple Branded Mail?](/docs/knowledge-base/how-do-i-set-up-apple-branded-mail)
>
> Display your brand logo in the Apple Mail inbox.

> [card] [How do I send with an avatar?](/docs/knowledge-base/how-do-i-send-with-an-avatar)
>
> Learn how to show your avatar in the inbox of your recipients.

> [card] [Forward emails with Resend Inbound](/docs/knowledge-base/forward-emails-with-resend-inbound)
>
> Set up email forwarding using Resend's inbound email processing.

> [card] [Template emails with React Email](/docs/knowledge-base/template-emails-with-react-email)
>
> Author email templates as React components and upload them to Resend with the
> CLI.

> [card] [Embed the React Email editor](/docs/knowledge-base/embed-react-email-editor)
>
> Add the open-source visual email editor to your own application.

## Troubleshooting

> [card] [How do I fix CORS issues?](/docs/knowledge-base/how-do-i-fix-cors-issues)
>
> Recommended options to avoid CORS errors when sending emails.

> [card] [403 Error: Domain Mismatch](/docs/knowledge-base/403-error-domain-mismatch)
>
> Resolve 403 errors when the sending domain doesn't match your verified domain.

> [card] [Domain Already Registered by Another Account](/docs/knowledge-base/domain-already-registered)
>
> Resolve domain ownership conflicts when a domain is already registered.

> [card] [Email says delivered but not received?](/docs/knowledge-base/what-if-an-email-says-delivered-but-the-recipient-has-not-received-it)
>
> Steps to take when an email is delivered but the recipient hasn't received it.

## AI Tools

> [card] [AI Onboarding](/docs/ai-onboarding)
>
> Everything you need to onboard your AI agent to Resend.

> [card] [MCP Server](/docs/mcp-server)
>
> Use Resend's Model Context Protocol server to send emails from AI tools.

> [card] [Email Best Practices Skills](/docs/email-best-practices-skill)
>
> Skills for AI agents to build production-ready email systems with Resend.

> [card] [React Email Skill](/docs/react-email-skill)
>
> Skills for AI agents to build HTML emails using React components with Resend.

> [card] [Resend Skill](/docs/resend-skill)
>
> Skills for AI agents to send emails with Resend.

## Account Management

> [card] [What is Resend Pricing?](/docs/knowledge-base/what-is-resend-pricing)
>
> Learn more about Resend's pricing plans.

> [card] [How can I delete my Resend account?](/docs/knowledge-base/how-can-i-delete-my-resend-account)
>
> Learn how to permanently delete your Resend account and data.

> [card] [How to handle API keys](/docs/knowledge-base/how-to-handle-api-keys)
>
> Best practices for managing and securing your Resend API keys.

> [card] [How to handle a leaked API key](/docs/knowledge-base/how-to-handle-a-leaked-api-key)
>
> What to do when an API key is exposed or used without authorization.

> [card] [How to add multi-factor authentication to your Resend account](/docs/knowledge-base/how-can-i-add-mfa)
>
> Enable or disable multi-factor authentication (MFA) or two-factor
> authentication (2FA) on your Resend account.

## Testing

> [card] [E2E Testing with Playwright](/docs/knowledge-base/end-to-end-testing-with-playwright)
>
> Set up end-to-end email testing with Playwright and Resend.

> [card] [What email addresses to use for testing?](/docs/knowledge-base/what-email-addresses-to-use-for-testing)
>
> Use Resend's test email addresses to simulate different delivery scenarios.


# Send emails with n8n and Resend
Source: https://resend.com/docs/knowledge-base/n8n-integration

Learn how to install and use the official Resend node for n8n to send emails, manage contacts and inboxes, handle webhooks, and more.

[n8n](https://n8n.io) is a workflow automation platform that lets you connect apps and build powerful automations. The official [Resend node](https://github.com/resend/n8n-nodes-resend) (`n8n-nodes-resend`) provides full coverage of the Resend API. From within n8n, you can send emails, run broadcasts and automations, manage contacts, domains, and inboxes, and trigger workflows from Resend events.

![Resend node in the n8n editor](https://mintcdn.com/resend/bsGJjyDJfHnB7xCx/images/n8n-integration.png?fit=max\&auto=format\&n=bsGJjyDJfHnB7xCx\&q=85\&s=ed6c44c61540d4e88607a123ffb9c1c9)

## How to use Resend's n8n node

**1. Install the Resend node**

1. Open the nodes panel by selecting **+** or pressing **Tab**
2. Search for **Resend**
3. Select **Install** to install the node for your instance
4. The node is now available in all your workflows

<video />

**2. Setup Resend**

1. [Create an API Key](https://resend.com/api-keys): copy this key to your clipboard
2. [Verify your own domain](https://resend.com/domains): to send to email addresses other than your own

**3. Connect your Resend account**

The Resend node supports two authentication methods. Choose one in the node's **Authentication** field.

**OAuth2 (recommended)**

1. In n8n, go to **Credentials** > **Add credential**.
2. Search for **Resend OAuth2 API** and select **Connect my account**.

n8n registers itself as an OAuth client with Resend, so you don't need to create or paste an API key.

> [!NOTE]
>
> OAuth2 relies on Dynamic Client Registration support in n8n core. If **Connect
> my account** doesn't work, update to a recent n8n version or use the **Resend
> API** credential instead.

**API key**

1. In n8n, go to **Credentials** > **Add credential**.
2. Search for **Resend API** and paste your API key.

<video />

The credential you choose is used by the main **Resend** node for all API operations.

**4. Send your first email**

1. Click the **+** (Add node) connector on the canvas.
2. Search for **Resend** in the nodes panel.
3. n8n displays a list of available actions — select **Send an Email**.
4. The Resend node is added to your workflow with the **Send** operation pre-selected.
5. Fill in the **From**, **To**, **Subject**, and **Email Body** fields.
6. Execute the node.

> [!NOTE]
>
> By default, you can only send emails to your own email address using the
> `onboarding@resend.dev` sender domain. To send to other recipients, [add a
> custom domain](/docs/dashboard/domains/introduction) to your Resend account.

## Human in the Loop (Send and Wait)

The **Send and Wait for Response** operation enables human-in-the-loop workflows. Send an email and pause the workflow until the recipient responds, via approval buttons or a free-text form.

1. In the nodes panel, go to **Human in the Loop** > **Resend**, or select the **Email** resource and the **Send and Wait for Response** operation.
2. Choose a **Response Type**: **Approval** (buttons) or **Free Text** (form).
3. Configure the email content and any wait-time limits.
4. The workflow pauses until the recipient clicks a button or submits the form.

| Option | Description |
| - | - |
| **Response Type** | Choose between Approval (buttons) or Free Text (form) |
| **Approval Type** | Single button (Approve only) or Double (Approve/Decline) |
| **Button Labels** | Customize the button text |
| **Button Styles** | Primary or Secondary button styling |
| **Message Button Label** | Label for the form link button (Free Text mode) |
| **Response Form Title** | Title shown on the response form |
| **Limit Wait Time** | Set a timeout for the wait period |

## Receive webhooks with the Resend Trigger

The **Resend Trigger** node lets you start workflows automatically when events occur in Resend (e.g., an email is delivered or bounced, a contact is created, or an inbox receives an email). Webhook signatures are verified automatically using Svix.

### Set up the Trigger node

1. Add a **Resend Trigger** node to your workflow.
2. Create a **Resend Webhook Signing Secret** credential:
   * Create a webhook endpoint in the [Resend Dashboard](https://resend.com/webhooks).
   * Copy the signing secret (starts with `whsec_`).
   * In n8n, go to **Credentials** > **Add credential**, search for **Resend Webhook Signing Secret**, and paste the secret.

> [!NOTE]
>
> Give each webhook credential a unique name (e.g., "Resend Webhook — Bounces"
> or "Resend Webhook — Delivery Events"). This makes it much easier to identify
> the right credential when you have multiple triggers connected to different
> webhooks.

3. Select the events you want to listen for.
4. Copy the **webhook URL** from the Trigger node and paste it into your Resend Dashboard webhook configuration.

### Supported trigger events

| Event | Description |
| - | - |
| `email.sent` | Email sent to recipient |
| `email.delivered` | Email delivered successfully |
| `email.delivery_delayed` | Email delivery delayed |
| `email.failed` | Email failed to send due to an error (for example, invalid recipients, API key issues, domain verification, or quota limits) |
| `email.opened` | Recipient opened the email |
| `email.clicked` | Link clicked in email |
| `email.bounced` | Email bounced |
| `email.complained` | Spam complaint received |
| `email.received` | Resend successfully received an inbound email |
| `email.scheduled` | Email is scheduled to be sent |
| `email.suppressed` | Email is suppressed by Resend |
| `contact.created` | New contact added |
| `contact.updated` | Contact modified |
| `contact.deleted` | Contact removed |
| `contact.topics.updated` | Contact's topic subscriptions changed |
| `domain.created` | New domain added |
| `domain.updated` | Domain modified |
| `domain.deleted` | Domain removed |
| `suppression.added` | Email address added to your suppression list |
| `suppression.removed` | Email address removed from your suppression list |
| `topic.created` | New topic added |
| `topic.updated` | Topic modified |
| `topic.deleted` | Topic removed |
| `inbox.created` | New inbox added |
| `inbox.updated` | Inbox modified |
| `inbox.deleted` | Inbox removed |
| `inbox.email.received` | Inbox received an email |
| `inbox.email.sent` | Email sent from an inbox |
| `inbox.thread.created` | New inbox thread started |
| `inbox.thread.assigned` | Inbox thread assigned |
| `inbox.thread.unassigned` | Inbox thread unassigned |
| `inbox.thread.folder.updated` | Inbox thread moved to a different folder |
| `inbox.thread.labels.updated` | Inbox thread labels changed |
| `inbox.draft.created` | Inbox draft created |
| `inbox.draft.updated` | Inbox draft modified |
| `inbox.draft.sent` | Inbox draft sent |
| `inbox.draft.deleted` | Inbox draft removed |

For event payloads, see [Event Types](/docs/webhooks/event-types).

## Supported resources

The **Resend** node covers the full Resend API:

| Resource | Operations |
| - | - |
| **Email** | Send, Send Batch, Send and Wait, List, Get, Update, Cancel, Share, Get Metrics, List Attachments, Get Attachment |
| **Receiving Emails** | List, Get, List Attachments, Get Attachment |
| **Inboxes** | Create, List, Get, Update, Delete, Get Agent Settings, Update Agent Settings, Create Label, List Labels, Update Label, Delete Label |
| **Inbox Threads** | List, Search, Get, Update, Delete, Add Labels, Set Labels, Remove Label, List Emails, Get Email, Reply, Forward |
| **Inbox Drafts** | Create, List, Get, Update, Delete, Send |
| **Broadcasts** | Create, List, Get, Update, Delete, Send, Cancel, Duplicate, List Clicked Links, List Recipients |
| **Templates** | Create, List, Get, Update, Delete, Publish, Duplicate |
| **Automations** | Create, List, Get, Update, Delete, Duplicate, Stop, List Runs, Get Run |
| **Events** | Create, List, Get, Update, Delete, Send |
| **Contacts** | Create, List, Get, Update, Delete, Add to Segment, List Segments, Remove from Segment, Get Topics, Update Topics, Create Import, List Imports, Get Import |
| **Contact Properties** | Create, List, Get, Update, Delete |
| **Segments** | Create, List, Get, Update, Delete, List Contacts, Get Metrics |
| **Topics** | Create, List, Get, Update, Delete |
| **Suppressions** | Create, List, Get, Delete, Batch Add, Batch Remove |
| **Domains** | Create, List, Get, Update, Delete, Verify, Claim, Get Claim, Verify Claim |
| **Webhooks** | Create, List, Get, Update, Delete, Rotate Signing Secret, List Events, Get Event, Replay Event, List Event Attempts |
| **Logs** | List, Retrieve |
| **Account** | Get Usage, List Grants, Revoke Grant, Disconnect (OAuth2 credential only) |

> [!NOTE]
>
> Upgrading from v2? Version 3 renames the **Workflow** resource to
> **Automation** and moves tracking domains into the **Tracking Subdomain**
> option on **Domain** > **Create** and **Update**. See the [migration
> guide](https://github.com/resend/n8n-nodes-resend#migrating-to-v300) for all
> breaking changes.

## Example workflow: Send a welcome email when a contact is created

Here's a simple workflow you can build with the Resend nodes:

1. **Resend Trigger**: listens for `contact.created` events.
2. **Resend** (Email > Send): sends a welcome email to the new contact using data from the trigger.

The Trigger-Action pattern works for any event. For example, you can notify your team on Slack when an email bounces, or log delivery events to a spreadsheet.

For ready-to-import workflows, including bounce handling, newsletter broadcasts, drip campaigns, and approval flows, see the [example workflows](https://github.com/resend/n8n-nodes-resend/tree/main/examples) in the node's repository.

> [!NOTE]
>
> The Resend node is also available as an [AI
> tool](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolworkflow/)
> in n8n, so you can use it inside AI agent workflows.


# How to prevent bounces with @privaterelay.appleid.com recipients?
Source: https://resend.com/docs/knowledge-base/sending-apple-private-relay

Sending to Apple Private Email Relay requires specific configuration steps to ensure your emails get delivered

If your website or application supports Sign In with Apple, your customers have the option to receive emails from you via Apple’s Private Email Relay service. This feature allows users to keep their actual email addresses private when they sign up or log in.

When a user selects the Hide My Email option, Apple assigns them a unique, randomly generated email address under the `@privaterelay.appleid.com` domain, which you can link to that specific user.

To ensure your emails are delivered through Apple’s Private Email Relay, you must first access the Apple Developer Portal and navigate to `Certificates, Identifiers & Profiles` > `More` > `Sign in with Apple for Email Communication` > `Configure`.

> [!NOTE]
>
> **Apple Offers Multiple Hide My Email Services**
>
> Starting with iOS 15, Apple provides two separate Hide My Email services—one through Sign in with Apple and another via iCloud+.
>
> This guide is specifically for apps and websites utilizing Sign in with Apple, which generates a unique email address for account creation and login purposes.

## Register your sending domains

Apple mandates that you list the domains from which you will send emails to its service. Additionally, if your return-path domain differs from your sending domain, you must include that as well.

If you use Resend, note that its return-path domain is different since it operates through a subdomain. You will find this subdomain in your Domain settings, formatted as `send.yourdomain.tld` or `send.yoursubdomain.yourdomain.tld` for MX and SPF records. Ensure you add both your primary domain and the subdomain as Apple Email Sources.

## Register your email addresses

Alongside your Sending Domains, Apple requires registration of all email addresses used to send messages from those domains.

You can add these email addresses one by one or in a comma-separated list. If you use other email sources outside of Resend to send messages to Private Relay addresses, include those as well.

## Authenticate your sending domains

Since Resend mandates SPF and DKIM authentication for all domains sending emails through its service, your domain will automatically meet Apple’s authentication requirements.

## Troubleshooting bounces from @privaterelay.appleid.com

At times, emails sent to `@privaterelay.appleid.com` may still bounce. While the bounce messages may not always contain detailed explanations, common reasons include:

* The user has deleted their Hide My Email address from Apple’s settings.
* The user has exceeded their daily limit of 100 emails sent to and from their Hide My Email address.
* A misconfiguration in your settings. Double-check that all Sending Domains and From Addresses are correctly registered and authenticated with Apple.

Apple allows the account owner and admins in the Apple Developer Portal to receive notifications if messages fail to deliver through the relay. You can enable this setting in the portal.

***

Once you have completed these three steps, you will be ready to send emails to customers using Hide My Email addresses via Apple’s Private Email Relay service.

For additional details on Apple Private Email Relay and configuration options, refer to Apple’s official documentation:

* [Apple: Configure Private Email Relay Service](https://developer.apple.com/help/account/configure-app-capabilities/configure-private-email-relay-service/)
* [Apple: Communicating Using the Private Email Relay Service](https://developer.apple.com/documentation/signinwithapple/communicating-using-the-private-email-relay-service/)


# Setting up Resend for Multi-Tenant Applications
Source: https://resend.com/docs/knowledge-base/setting-up-resend-for-multi-tenants

Learn how to configure Resend for SaaS platforms where tenants send emails from their own domains.

Many SaaS platforms need to send emails on behalf of their tenants: whether it's transactional notifications, onboarding sequences, or marketing campaigns from a tenant's own domain. This guide walks through the two main approaches to configuring Resend for multi-tenant email sending.

> [!NOTE]
>
> There is no single "right" approach. Both options described below are valid
> and widely used. The best choice depends on your product's requirements, how
> much control you want over the sending experience, and your tenants' needs.

## At a glance

| Factor | Single Account | Separate Accounts / BYOK |
| - | - | - |
| **Setup complexity** | Low: fully API-driven | Higher: manual account creation per tenant |
| **Sending isolation** | Shared: one bad actor affects all | Full: each tenant is isolated |
| **Billing** | Single plan covers all tenants | Each tenant manages their own plan |
| **Per-tenant analytics** | Not available natively | Each tenant has own dashboard |
| **Webhook routing** | Via tags or `from` domain | Each account has its own webhooks |
| **Deliverability** | Shared sender reputation | Independent sender reputation |
| **Rate limits** | Aggregate volume: likely requires an increase | Each tenant uses their own limits |
| **Troubleshooting** | Full visibility into all tenant emails | Requires access to tenant's account |

## Option A: Single Resend account

### How it works

In this approach, you manage everything from a single Resend account. You add each tenant's domain to your account, verify it, and create domain-scoped API keys so that each tenant can only send from their own domain. All sending, billing, and analytics flow through your account.

### Setting up a tenant domain

When a tenant signs up and wants to send from their own domain, you create and verify the domain via the API.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
const domain = await resend.domains.create({ name: 'tenant-domain.com' });

// After the tenant adds DNS records, trigger verification
await resend.domains.verify(domain.id);
```

> [!NOTE]
>
> Domain verification is asynchronous: DNS records need to propagate before
> verification succeeds. You can use [webhooks](/docs/webhooks/introduction) to
> listen for `domain.verified` events instead of polling.

### Creating a domain-scoped API key

Once the domain is verified, create an API key scoped to that domain. This ensures the tenant can only send from their own domain.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
const apiKey = await resend.apiKeys.create({
  name: 'Tenant: tenant-domain.com',
  permission: 'sending_access',
  domain_id: domain.id,
});
```

> [!WARNING]
>
> The API key token is only returned once at creation time. Store it securely:
> you will not be able to retrieve it again.

### Pros

* Seamless, fully API-driven setup: no manual steps required
* Domain-scoped API keys limit each tenant to their own domain
* Single account to manage billing, monitoring, and configuration

### Cons

* No per-tenant volume breakdown or analytics in the dashboard
* All tenants share your account's sender reputation
* Aggregate sending volume will likely require a [rate-limit increase](/docs/knowledge-base/account-quotas-and-limits) as you onboard tenants
* Each tenant domain counts toward your team's domain limit, which you can raise with the [domains add-on](/docs/knowledge-base/how-to-add-more-domains)

> [!WARNING]
>
> If one tenant engages in poor sending practices (spam, high bounce rates), it
> can affect deliverability for all tenants on your account. In severe cases,
> the entire account may be suspended.

## Option B: Separate accounts (BYOK)

### How it works

In the Bring Your Own Key (BYOK) model, each tenant creates their own Resend account, adds their domain, and provides you with their API key. Your application stores each tenant's API key and uses it when sending on their behalf.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
// Initialize a Resend client with the tenant's own API key
const resend = new Resend(tenantApiKey);

await resend.emails.send({
  from: 'notifications@tenant-domain.com',
  to: 'user@example.com',
  subject: 'Your order has shipped',
  html: '<p>Your order #1234 is on its way.</p>',
});
```

### Pros

* Full sending isolation: each tenant's reputation and deliverability are independent
* No liability for tenant sending behavior on your account
* Tenants who already use Resend can reuse their existing account
* Each tenant has their own dashboard with analytics and logs
* Each tenant uses their own rate limits, so you're less likely to need increases

### Cons

* Requires each tenant to create a Resend account and manage their own plan
* More onboarding friction for tenants unfamiliar with email infrastructure

> [!NOTE]
>
> Team creation is not currently available via the API. Each tenant will need to
> create their Resend account manually through the
> [dashboard](https://resend.com/signup).

## Billing implications

With **Option A**, you pay a single plan that covers all tenant sending volume. Your total email count is the aggregate of all tenants' emails, so choose a plan that accommodates your combined volume. Since each tenant domain counts toward your domain limit, you may also need to [add more domains](/docs/knowledge-base/how-to-add-more-domains) as you grow.

With **Option B**, each tenant is responsible for their own Resend plan and billing. This removes billing complexity from your side but means tenants need to manage their own subscription. See [Resend pricing](/docs/knowledge-base/what-is-resend-pricing) and [account quotas and limits](/docs/knowledge-base/account-quotas-and-limits) for details.

## Deliverability considerations

Sender reputation is tied to the sending account and its associated domains and IPs. This is the most important distinction between the two approaches.

With **Option A**, all tenants share the same sender reputation. If a single tenant sends to stale lists, generates high bounce rates, or triggers spam complaints, it can degrade deliverability for every tenant on your account. In the worst case, your entire account faces suspension.

With **Option B**, each tenant has a fully independent sender reputation. A problem with one tenant has zero impact on others. However, each tenant is responsible for following best practices on their own.

Regardless of which approach you choose, each new tenant domain must follow a [warm-up schedule](/docs/knowledge-base/warming-up). Using a [subdomain](/docs/dashboard/domains/introduction#subdomains) for sending is also a good practice to protect the tenant's root domain reputation.

## Webhook routing

### Option A: Tags for tenant identification

When using a single account, use [tags](/docs/dashboard/emails/tags) when sending emails to identify which tenant triggered the message. Tags are included in webhook payloads, so you can route events back to the correct tenant.

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
await resend.emails.send({
  from: 'notifications@tenant-domain.com',
  to: 'user@example.com',
  subject: 'Welcome aboard',
  html: '<p>Thanks for signing up.</p>',
  tags: [{ name: 'tenant_id', value: 'tenant_abc123' }],
});
```

When you receive a [webhook](/docs/webhooks/introduction) event, the `tags` array in the payload will include `tenant_id`, allowing you to route the event to the appropriate tenant in your system.

### Option B: Natural isolation

With separate accounts, each tenant configures their own webhooks in their Resend dashboard. Events are naturally isolated: you don't need to tag or filter anything.

## Migrating between approaches

If your needs change, you can migrate from one approach to the other.

**A to B (Single Account → Separate Accounts):**

* Each tenant creates their own Resend account
* Tenants add and verify their domains in their new accounts
* You replace the shared API key with each tenant's individual key in your application
* Remove the tenant domains from your original account

**B to A (Separate Accounts → Single Account):**

* Add each tenant's domain to your central account and verify DNS records
* Create domain-scoped API keys for each tenant
* Update your application to use the new keys
* Tenants can deactivate their individual accounts

> [!WARNING]
>
> When moving a domain between accounts, it will need to be deleted from the
> original account before being re-verified in the second account. Plan for
> potential sending interruptions during the DNS propagation window.

## Share your feedback

Please share any feedback on your experience using Resend for your multi-tenant application to help us better serve this use case.

> [!NOTE]
>
> We're tracking interest for improved multi-tenant capabilities. Share your use
> case at [support@resend.com](mailto:support@resend.com).

## Related resources

> [card] [Create Domain API](/docs/api-reference/domains/create-domain)
>
> Add and verify tenant domains programmatically.

> [card] [Create API Key API](/docs/api-reference/api-keys/create-api-key)
>
> Create domain-scoped API keys for tenant isolation.

> [card] [Webhooks](/docs/webhooks/introduction)
>
> Set up webhooks to receive real-time email event notifications.

> [card] [Managing Tags](/docs/dashboard/emails/tags)
>
> Use tags to organize emails and route webhook events by tenant.


# Do you need to add an unsubscribe link to all of your emails sent with Resend?
Source: https://resend.com/docs/knowledge-base/should-i-add-an-unsubscribe-link

Learn best practices about using unsubscribe links.

Transactional emails are generally exempt from including an unsubscribe link. Unlike marketing emails, transactional emails serve a functional purpose, such as account confirmation, password resets, and order confirmations.

As a best practice, tell recipients how to opt out of receiving future email from you if the content is more related to nurturing relationships with your customers, rather than pragmatic, action-oriented emails.

Laws enforced by the FTC and GDPR prioritize giving recipients a clear way to give and withdraw their consent to receiving email marketing content. Additionally, not having an option for opting out of emails risks recipients complaining or marking the email as spam, which can hurt your reputation as a sender.

Here is more on how to [manually add and manage unsubscribe links](https://resend.com/docs/dashboard/emails/add-unsubscribe-to-transactional-emails).

If you're using [Resend Broadcasts or Automations](https://resend.com/docs/dashboard/audiences/managing-unsubscribe-list), Resend will automatically handle unsubscribe requests once you include `{{{RESEND_UNSUBSCRIBE_URL}}}` in your email. You can include the Unsubscribe Footer in your Broadcasts, which will be automatically replaced with the correct link for each contact, or use `{{{RESEND_UNSUBSCRIBE_URL}}}` as a link target if you want to customize the unsubscribe footer.


# Template emails with React Email
Source: https://resend.com/docs/knowledge-base/template-emails-with-react-email

Author email templates as React components and upload them to Resend with the CLI.

With [React Email](https://react.email), write email templates as React components, with full TypeScript and [Tailwind support](https://react.email/docs/components/tailwind), and a local preview server. Preview your emails in real time with hot reloading, and render to email-friendly HTML or plain text when you're ready to send.

This guide walks through setting up a React Email project, writing a template, and uploading it to [Resend Templates](/docs/dashboard/templates/introduction) with the [Resend CLI](/docs/cli) so the rest of your team can collaborate on it in the dashboard.

**1. Set up a React Email project**

Use `create-email` to scaffold a project with a starter template, a preview server, and the `@react-email/components` package.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npx create-email@latest
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn create email
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm create email
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun create email
```

This creates a new `react-email-starter` folder with an `emails/` directory and a few example templates. Install dependencies:

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
cd react-email-starter
npm install
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
cd react-email-starter
yarn
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
cd react-email-starter
pnpm install
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
cd react-email-starter
bun install
```

> [!TIP]
>
> Already have a project? See the [React Email
> docs](https://react.email/docs/getting-started/manual-setup) for the manual
> setup and then create an `emails/` directory in your preferred location.

**2. Write your template**

Create `emails/welcome.tsx`. Each component can be imported from `react-email` ([view all components](https://react.email/docs/components/html)). Optionally add props to the component to be used as variables when sending.

```tsx emails/welcome.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import {
  Body,
  Button,
  Container,
  Head,
  Heading,
  Html,
  Preview,
  Section,
  pixelBasedPreset,
  Tailwind,
  Text,
} from 'react-email';
import * as React from 'react';

interface WelcomeEmailProps {
  firstName?: string;
  productName?: string;
}

export default function WelcomeEmail({
  firstName = 'there',
  productName = 'Acme',
}: WelcomeEmailProps) {
  return (
    <Html>
      <Head />
      <Tailwind config={{ presets: [pixelBasedPreset] }}>
        <Preview>Welcome to {productName}</Preview>
        <Body className="bg-white font-sans">
          <Container className="mx-auto py-12">
            <Heading className="text-2xl font-semibold text-black">
              Welcome, {firstName}
            </Heading>
            <Text className="text-base text-zinc-700">
              Thanks for signing up for {productName}. Let's get you started.
            </Text>
            <Section className="mt-6">
              <Button
                className="rounded-md bg-black px-5 py-3 text-sm font-medium text-white"
                href="https://example.com/get-started"
              >
                Get started
              </Button>
            </Section>
          </Container>
        </Body>
      </Tailwind>
    </Html>
  );
}
```

**3. Add email script**

```json package.json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "scripts": {
    "email:dev": "email dev"
  }
}
```

The `email:dev` script will start the preview server. If your `email` directory is not in the root of your project, you can specify the path to it.

```json package.json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "scripts": {
    "email:dev": "email dev --dir src/emails"
  }
}
```

**4. Preview locally**

Run the preview server to see your email render in real time as you edit. Hot reload picks up changes automatically.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm run email:dev
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn email:dev
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm email:dev
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun email:dev
```

Open [localhost:3000](http://localhost:3000) and select `welcome.tsx` from the sidebar.

![React Email Preview server](https://mintcdn.com/resend/76EbQM9CtFOSLM5w/images/react-email-preview-server.png?fit=max\&auto=format\&n=76EbQM9CtFOSLM5w\&q=85\&s=cdff7167cb9fe636c6c4432be3f8be58)

The preview shows the rendered email and offers desktop/mobile toggles, the source HTML, and plain-text output. Changes you make to `welcome.tsx` show in real-time and dedicated email tools show in the toolbars.

* `Linter`: lint your email content, links, and more.
* `Compatibility`: check your email's HTML/CSS with [caniemail](https://caniemail.com).
* `Spam`: see how spam checkers view your email.

**5. Send your email template**

You can pass your React Email template in the email call using the Resend Node SDK.

```ts sendEmail.tsx {10} theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { Email } from './email';

const resend = new Resend('re_123456789');

await resend.emails.send({
  from: 'you@example.com',
  to: 'delivered@resend.com',
  subject: 'hello world',
  react: <Email url="https://example.com" />,
});
```

**6. Upload your template to Resend**

[Templates](/docs/dashboard/templates/introduction) are stored on Resend and can be referenced when you send transactional emails. With Templates, define the structure and layout of a message and optionally include custom variables which will be replaced with the actual values when sending the email.

Set up the Resend integration using the React Email CLI:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}} theme={"theme":{"light":"github-light","dark":"vesper"}}
npx react-email@latest resend setup
```

This will prompt you to enter your Resend API Key. To get one, navigate to [API Keys](https://resend.com/api-keys) in your Resend dashboard, click **Create API key**, and ensure that the API Key is scoped to **Full Access**.

Paste the API Key into the terminal and press enter.

Run the React Email preview server and visit the **Resend** tab of the toolbar. Choose **Upload** or **Bulk Upload** to import your Template to Resend.

<video />

If you want to remove the Resend integration, run `npx react-email@latest resend reset`.

> [card] [React Email components](https://react.email/docs/components/html)
>
> Browse every available component — Button, Container, Tailwind, and more.

> [card] [Resend CLI reference](/docs/cli)
>
> See every CLI command and flag, including templates, automations, and
> webhooks.

> [card] [Templates introduction](/docs/dashboard/templates/introduction)
>
> Learn how Templates, variables, and version history work in Resend.

> [card] [Embed the React Email editor](/docs/knowledge-base/embed-react-email-editor)
>
> Add the open-source visual editor to your own app.


# Domain and/or IP Warm-up Guide
Source: https://resend.com/docs/knowledge-base/warming-up

Learn how to warm up a domain or IP to avoid deliverability issues.

Warming up a domain or IP refers to the practice of progressively increasing your sending volume to maximize your deliverability. The goal is to send at a consistent rate and avoid any spikes in email volume that might be concerning to inbox service providers.

Whenever you change your sending patterns, warm up your domain and/or IP. This applies when you use a new domain, a new IP, or a new vendor, or when your volume will increase.

A thought-out warm-up plan limits greylisting and delivery throttling, as well as helping establish a good domain and IP reputation.

As your volume increases, you'll need to monitor your bounce rate to ensure it remains below 4%, and your spam rate below 0.08%. An increase in these rates would be a sign that your warm-up plan needs to be slowed down and an investigation into the root causes of the increases started.

Following these rules and metrics will establish a good domain reputation.

> [!NOTE]
>
> Each sender has different constraints and needs, so these numbers are meant as
> a baseline. Our [Support team](https://resend.com/help) can work with you on
> devising a plan adapted to your needs.

## Existing domain

If you're already sending from an existing domain with established reputation and volumes, you can use the following guidelines to start sending with Resend.

| **Day** | **Messages per day** | **Messages per hour** |
| - | - | - |
| **1** | Up to 1,000 emails | 100 Maximum |
| **2** | Up to 2,500 emails | 300 Maximum |
| **3** | Up to 5,000 emails | 600 Maximum |
| **4** | Up to 5,000 emails | 800 Maximum |
| **5** | Up to 7,500 emails | 1,000 Maximum |
| **6** | Up to 7,500 emails | 1,500 Maximum |
| **7** | Up to 10,000 emails | 2,000 Maximum |

## New domain

Before you start sending emails with a brand new domain, it's especially important to have a warm-up plan so you can maximize your deliverability right from the start.

| **Day** | **Messages per day** | **Messages per hour** |
| - | - | - |
| **1** | Up to 150 emails | |
| **2** | Up to 250 emails | |
| **3** | Up to 400 emails | |
| **4** | Up to 700 emails | 50 Maximum |
| **5** | Up to 1,000 emails | 75 Maximum |
| **6** | Up to 1,500 emails | 100 Maximum |
| **7** | Up to 2,000 emails | 150 Maximum |

## Warm-up calculator

Use the calculator below to generate a personalized warm-up schedule based on your specific needs. Enter your target volume, timeline, and domain type to get a custom plan.

The guide is meant as a general plan, but always pay careful attention to your deliverability and adjust accordingly. If you have specific questions, [please reach out to us](https://resend.com/help).

Domain Type

New Domain

Existing Domain

Target Daily Volume

Start Date

Target Date (optional)

Warm-up Duration

days

Start Date

Full Capacity Date

Target Volume

/day

**Day**

**Date**

**Messages per day**

**Messages per hour**

Tip

As you warm up, keep your **bounce rate below 4%** and
your **spam rate below 0.08%**. If these rates increase,
slow down your warm-up and investigate the root cause before
continuing.

# Warming up your Dedicated IP with Resend

In order for a Dedicated IP to be beneficial or useful, you first need to establish a certain sending volume and patterns. Once you've established this volume and these patterns, our [Support team](https://resend.com/help) can set it up for you.

Resend provides an automatic warm-up process so that you can focus on sending.

[Learn more about requesting a Dedicated IP](https://resend.com/docs/knowledge-base/how-do-dedicated-ips-work#how-to-request-a-dedicated-ip).

# Third-party warm-up services

Email deliverability is important, and it can be tempting to use services promising quick fixes. However, using tools that artificially boost engagement can harm your long-term sender reputation. These services often rely on manipulating anti-spam filters, which can backfire as email providers like Gmail adjust their systems.

Instead, focus on sustainable practices, such as sending relevant content, maintaining a clean list, and using proper authentication. These methods build trust with email providers and improve your deliverability over time.


# What attachment types are not supported?
Source: https://resend.com/docs/knowledge-base/what-attachment-types-are-not-supported

Learn which file attachment extensions you can't send.

You can **send** any file attachment types except for those in the following list.

| | | | | |
| - | - | - | - | - |
| .adp | .app | .asp | .bas | .bat |
| .cer | .chm | .cmd | .com | .cpl |
| .crt | .csh | .der | .exe | .fxp |
| .gadget | .hlp | .hta | .inf | .ins |
| .isp | .its | .js | .jse | .ksh |
| .lib | .lnk | .mad | .maf | .mag |
| .mam | .maq | .mar | .mas | .mat |
| .mau | .mav | .maw | .mda | .mdb |
| .mde | .mdt | .mdw | .mdz | .msc |
| .msh | .msh1 | .msh2 | .mshxml | .msh1xml |
| .msh2xml | .msi | .msp | .mst | .ops |
| .pcd | .pif | .plg | .prf | .prg |
| .reg | .scf | .scr | .sct | .shb |
| .shs | .sys | .ps1 | .ps1xml | .ps2 |
| .ps2xml | .psc1 | .psc2 | .tmp | .url |
| .vb | .vbe | .vbs | .vps | .vsmacros |
| .vss | .vst | .vsw | .vxd | .ws |
| .wsc | .wsf | .wsh | .xnk | |

> [!NOTE]
>
> You can *receive* any file attachment types, including those listed above.
> These restrictions only apply to *sending* attachments.


# What counts as email consent?
Source: https://resend.com/docs/knowledge-base/what-counts-as-email-consent

Learn what valid email permission looks like and why it matters.

Getting consent to send email isn’t only a legal requirement. It’s also essential for keeping your deliverability strong and your Resend account in good standing.

This guide explains what valid email permission looks like, why it matters, and how to set it up properly.

## Why consent matters

Many senders assume that if someone provides an email address, that automatically means it’s okay to email them. But that’s not always true and can often cause large-scale deliverability problems, especially for marketing or bulk messages.

Mailbox providers like Gmail and Outlook closely monitor how recipients react to your emails, paying special attention to whether people mark your emails as spam. High complaint rates or low overall engagement signal that your messages weren’t wanted, which can hurt your reputation and lead to filtering, blocking, or delivery issues.

## What *doesn’t* count as permission

These common methods are not considered valid:

* Including a clause in your Terms of Service that says users “agree to receive emails”
* Using a **pre-checked** box on your signup form for marketing messages
* Assuming someone is opted in unless they unsubscribe

These approaches violate email best practices and don’t meet legal standards [like GDPR](https://gdpr-info.eu/art-7-gdpr/).

## What *does* count as permission

Valid consent means the recipient **clearly and knowingly agreed** to receive the specific kind of email you're sending.

[According to GDPR](https://gdpr-info.eu/recitals/no-32/) (and general best practices), consent must be:

* **Freely given** – without pressure, bundling, or tricks
* **Specific** – clearly describes the type of messages the user will receive
* **Informed** – the user knows who you are and how you’ll use their data
* **Unambiguous** – requires an active opt-in (like checking a box)

In other words, recipients must be able to consent to each message type from a particular sender.

## What happens if you send without consent

If you send to recipients who didn’t explicitly opt in, here’s what can happen:

1. Some of those people will **mark the message as spam**.
2. Mailbox providers may **block your mail or filter it to the spam folder**.
3. If your spam complaint or bounce rate remains high, [Resend may have to **pause or terminate your account**](https://resend.com/legal/acceptable-use) to protect our sending reputation.

And this applies *globally*, not only in the EU. Even if your emails are technically legal in your country, violating consent can lead to your mail being blocked or filtered to the spam folder.

## Best practice: Let people say “yes”

The easiest way to get consent is to **ask for it clearly and separately**. Add an unchecked checkbox to your signup form, like this:

>  Yes, I want to receive product updates and occasional marketing emails

**Follow these best practices:**

* Keep it **optional** and **unchecked** by default
* Make the wording clear and specific
* Place it outside of your Terms of Service
* Include a one-click unsubscribe link in every email

![Example of a consent checkbox and unsubscribe link](https://mintcdn.com/resend/lyl6PQTYhtWhUjuS/images/what-counts-as-email-consent.jpeg?fit=max\&auto=format\&n=lyl6PQTYhtWhUjuS\&q=85\&s=db80d9ae5b8eae269c0f7237d0f92ef0)

## Get more help

Following best practices helps everyone: your recipients, your deliverability, and the health of the email ecosystem. When you start with clear consent, your messages are the ones people are *glad* to receive.

If you’re new to permission-based sending, Resend [Support](https://resend.com/help) can help you get started.


# What email addresses to use for testing?
Source: https://resend.com/docs/knowledge-base/what-email-addresses-to-use-for-testing

Learn what email addresses are safe to use for testing with Resend

## Safe email addresses for testing

When testing email functionality, it's important to use designated test addresses to avoid unintended consequences like deliverability issues or spam complaints.

Resend provides a set of safe email addresses specifically designed for testing, ensuring that you can simulate different email events without affecting your domain's reputation.

### Avoid example or test domains

Many developers attempt to use domains like `@example.com` or `@test.com` for testing purposes. However, these domains are not designed for email traffic and often reject messages, leading to bounces.

A high bounce rate can negatively impact your sender reputation and affect future deliverability. To prevent this, Resend blocks such addresses and returns a `422 Unprocessable Entity` error if you attempt to send to them.

### List of addresses to use

To help you safely test email functionality, Resend provides the following test addresses, each designed to simulate a different delivery event:

| Address | Delivery event simulated |
| - | - |
| `delivered@resend.dev` | Email being delivered |
| `bounced@resend.dev` | Email bouncing |
| `complained@resend.dev` | Email marked as spam |
| `suppressed@resend.dev` | Email being suppressed |

Using these addresses in your tests allows you to validate email flows without risking real-world deliverability problems. For more help sending test emails, see our [testing documentation](/docs/dashboard/emails/send-test-emails).

### Labeling support

Most test email addresses support labeling, which enables you to send emails to the same test address in multiple ways. You can add a label after the `+` symbol to help track and differentiate between different test scenarios:

* `delivered+user1@resend.dev`
* `bounced+signup@resend.dev`
* `complained+newsletter@resend.dev`

This is particularly useful for testing different email flows, tracking webhook responses, and matching responses with the specific email address that triggered the event.

Whether you need to confirm that an email has been sent, track engagement events, or simulate a bounce scenario, these addresses provide a controlled and predictable way to test your email integration with Resend.

> [!WARNING]
>
> The suppressed test email address does not support labeling yet


# What if an email says delivered but the recipient has not received it?
Source: https://resend.com/docs/knowledge-base/what-if-an-email-says-delivered-but-the-recipient-has-not-received-it

Learn the steps to take when an email is delivered, but the recipient does not receive it.

Some emails may be marked as `Delivered` but not reach the recipient's inbox due to various inbox sorting variables. This guide provides reasons for and advice on avoiding such issues.

## Why does this happen

When an email is sent, it is marked as `Delivered` once the recipient server accepts it with a `250 OK` response. However, the server can then direct the email to the inbox, queue it for later, route it to the spam folder, or even discard it. This is done by major inbox providers (e.g., Gmail, Yahoo, Outlook), as well as by IT departments and individual users who set up firewalls or filtering rules.

As a result, even though most legitimate emails land in the intended inboxes, your message might end up in the spam/junk folder or, in rare cases, be deleted.

**Inbox Providers do not share any information on how the messages are later filtered.** Resend is only notified about the initial acceptance and marks the email as `Delivered`. Any subsequent events (e.g., open/click events, unsubscribes) require recipient engagement.

## How to avoid this

### If you are in contact with the user

The easiest way to solve this is by cooperating with the end user. If you have direct communication with the recipient, you can ask them to **check these places for your email**:

* Corporate spam filters or firewalls
* Personal inbox filtering
* Promotional, spam, or deleted folders
* Group inboxes or queues

If they find it, ask them to mark the email as `Not Spam` or add your domain to an allowlist.

### If you are not in contact with the user

Debugging without direct contact with the user is challenging. However, there are some optimizations that can **improve your chances of delivering to their inbox next time**:

* [Configure DMARC](/docs/dashboard/domains/dmarc) to build trust with the inbox provider
* Warm up new domains slowly before sending large volumes
* Change all links in your email to use your own domain (matching your sender domain)
* Turn off open and click tracking
* Reduce the number of images in your email
* Improve wording to be succinct, clear, and avoid spammy words

Check out our [extensive but practical deliverability guide](https://resend.com/guides/email/deliverability/avoid-gmail-spam-folder) that covers these topics in more detail.


# What if my domain is not verifying?
Source: https://resend.com/docs/knowledge-base/what-if-my-domain-is-not-verifying

Learn what steps to take when your domain doesn't seem to be verifying.

Verifying a domain involves a few steps:

1. Add your domain to Resend
2. Copy the required DNS records from Resend
3. Add these records to your DNS provider
4. Wait for verification to complete

When this process is completed correctly, your domain will often verify within 15 minutes of adding the DNS records.

> [!TIP]
>
> If you are having any conflict issues with the `MX` records, [check out this
> guide](/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).

## Common verification issues

When your domain doesn't verify as expected, it's typically due to DNS configuration issues. This guide will help you troubleshoot and resolve common verification problems.

> [!TIP]
>
> Resend provides real-time DNS validation when viewing your domain details.
> When viewing your domain, you'll see specific error messages and visual
> indicators highlighting any issues with your DNS records in case you've added
> them incorrectly.

### Incorrect DNS records

Usually when a domain doesn't verify, it's because the DNS records were not added correctly. Here's how to check:

1. Confirm that you've added every record shown in your domain's **Records** tab
2. Verify that the records are added at the correct location (the `send` subdomain, not the root domain)
3. Check that record values match exactly what Resend generated for you
4. Look for red wavy underlines on the domain details page (these indicate specific DNS record errors)

![Check for errors in the domain details page](https://mintcdn.com/resend/bOYCnBDaGARkhUDn/images/domain-not-verifying-3.png?fit=max\&auto=format\&n=bOYCnBDaGARkhUDn\&q=85\&s=f86be9e2a150af3c29aca6c69689842a)

> [!NOTE]
>
> The exact set of records depends on when your domain was created. Older
> domains show a `TXT` and an `MX` record for SPF, and both must be correct for
> SPF to verify at all. Domains created after August 2026 may show `CNAME`
> records instead. If you are shown two `CNAME` records, each is verified on its
> own, so one can verify while the other doesn't: your domain then shows as
> `partially_verified`, and you can still send, but without a fallback sending
> server.

### Proxied CNAME records

If your domain shows `CNAME` records for sending, check that they're not proxied at your DNS provider. On Cloudflare, this means the cloud icon next to the record must be gray (**DNS only**), not orange. Proxied records don't resolve as `CNAME`s, so verification never completes.

### CNAME records conflicting with existing records

A `CNAME` record can't co-exist with any other record on the same subdomain. If your DNS provider rejects the record, or verification keeps failing on a subdomain that already has an `A`, `TXT`, or `MX` record, you have two options:

1. Remove the existing records from that subdomain
2. [Configure a different Return-Path subdomain](/docs/dashboard/domains/custom-return-path) (e.g. `bounce.example.com`) and add the records Resend generates for it

### DNS provider auto-appending domain names

Some DNS providers automatically append your domain name to record MX values, causing verification failures.

**Problem:**

Your MX record appears as:

`feedback-smtp.eu-west-1.amazonses.com.example.com`

Instead of:

`feedback-smtp.eu-west-1.amazonses.com`

**Solution:**

In your DNS provider, add a trailing period (dot) at the end of the record value:

`feedback-smtp.eu-west-1.amazonses.com.`

The trailing period tells your DNS provider that this is a fully qualified domain name that must not be modified.

> [!TIP]
>
> Note: The region your domain is added to is in this MX record. It may be
> `us-east-1`, `eu-west-1`, `ap-northeast-1`, or `sa-east-1` depending on the
> region.

The same applies to the `CNAME` records shown for newer domains: if the value in your DNS provider shows the Resend host followed by your own domain name, add a trailing period to the value.

### Nameserver conflicts

If your domain's DNS is managed in multiple places (e.g., Vercel, Cloudflare, your domain registrar), you might be adding records in the wrong location.

**How to check:** Run a nameserver lookup for your domain using a tool like [dns.email](https://dns.email) to see which provider actually controls your DNS. Add the Resend records at that provider, not elsewhere.

### Region mismatch errors

If your MX records point to a different AWS region than where your domain is configured, you'll see a "region-mismatch" error. This happens when:

* Your domain is configured in one region (e.g., `us-east-1`)
* But your MX record points to a different region (e.g., `eu-west-1`)

**Solution:** Update your MX record to match the region shown in your Resend domain configuration. The correct MX record value is displayed in the DNS records table on your domain details page.

### Multiple regions detected

If you have multiple MX records pointing to different AWS regions, you'll see a "multiple-regions" error. All MX records for a domain must point to the same region.

**Solution:** Remove any MX records pointing to incorrect regions, keeping only the one that matches your domain's configured region.

> [!NOTE]
>
> Both region errors only apply to domains that show an `MX` record for SPF. If
> your domain shows `CNAME` records instead, the region is handled by the Resend
> host the record points to, so there's nothing to match.

### DKIM record value mismatches

The DKIM record must match exactly what Resend generated. Common mistakes include:

1. Adding extra quotes or spaces
2. Truncating long values
3. Adding SPF information to the DKIM record
4. Not copying the entire value

Always copy and paste the exact value from Resend's domain configuration page. If there's a mismatch, you'll see a red wavy underline on the incorrect value.

### DNS Propagation

After adding or correcting your DNS records:

1. DNS changes can take up to 72 hours to propagate globally (though often much faster)
2. Use the "Restart verification" button in the Resend dashboard to trigger a fresh verification check
3. If verification still fails after 24 hours, use [dns.email](https://dns.email) to check if your records are visible publicly

## Get more help

If you've followed all the steps above and your domain still isn't verifying, contact [Resend support](https://resend.com/help) with:

1. Your domain name
2. Screenshots of your DNS configuration

Our team will help identify any remaining issues preventing successful verification.

> [accordion] Check your records in the browser
>
> Tools like [dns.email](https://dns.email) allow you to check your DNS records in the browser.
>
> Go to this URL and replace `example.com` with the domain you added in Resend.
>
> ![Check domain records with dns.email](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/domain-not-verifying-1.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=0eb947321d0b35119432dab44d756260)
>
> You are looking to see the same values that you see in Resend.

> [accordion] Check your records in the terminal
>
> Checking your DNS records in the terminal is just as easy. You can use the `nslookup` command and a record type flag to get the same information.
>
> Replace `example.com` with whatever you added as the domain in Resend:
>
> Check your DKIM `TXT` record:
>
> ```
> nslookup -type=TXT resend._domainkey.example.com
> ```
>
> Check your SPF `TXT` record:
>
> ```
> nslookup -type=TXT send.example.com
> ```
>
> Check your SPF `MX` record:
>
> ```
> nslookup -type=MX send.example.com
> ```
>
> If your domain shows `CNAME` records for sending instead, check each of the shown CNAME records by name, as shown below:
>
> ```
> # If your domain shows two CNAME records, check both
> # Otherwise, only check the one that is shown in the Resend dashboard
> nslookup -type=CNAME send.example.com
> nslookup -type=CNAME rsend.example.com
> ```
>
> ![Check domain records with nslookup](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/domain-not-verifying-2.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=e48a16939eebfc986f9216a2cfd49b08)
>
> You are looking to see the same values that you see in Resend.


# What is Resend Pricing
Source: https://resend.com/docs/knowledge-base/what-is-resend-pricing

Learn more about Resend's pricing plans.

Resend offers Free, Pro, Scale, and Enterprise plans for transactional email, plus contact-based plans for marketing email. For the most up-to-date pricing, visit [resend.com/pricing](https://resend.com/pricing).

## Transactional Email

Transactional Email plans are based on the number of emails sent and received each month. Multiple `To`, `CC`, or `BCC` recipients count as separate emails.

| Plan | Price | Emails/mo | Overage per 1,000 emails |
| - | - | - | - |
| Free | \$0/mo | 3,000 | Not available |
| Pro | \$20/mo | 50,000 | \$0.90 |
| Pro | \$35/mo | 100,000 | \$0.90 |
| Scale | \$90/mo | 100,000 | \$0.90 |
| Scale | \$160/mo | 200,000 | \$0.80 |
| Scale | \$350/mo | 500,000 | \$0.70 |
| Scale | \$650/mo | 1,000,000 | \$0.65 |
| Scale | \$825/mo | 1,500,000 | \$0.52 |
| Scale | \$1,150/mo | 2,500,000 | \$0.46 |
| Enterprise | Custom | Custom | Custom |

The Free plan is limited to 100 emails per day. Paid plans have no daily sending limit, and overage rates apply only to emails sent beyond the included monthly volume.

For teams sending 1 million or more emails per month, Resend offers custom Enterprise plans that include:

* Volume-based pricing
* Priority support
* SLA guarantees
* Flexible data retention
* SSO
* Dedicated IP options

[Contact sales](https://resend.com/help) to learn more.

## Marketing Email

Marketing Email plans are based on the number of contacts, not the number of emails sent. Broadcasts can only be sent to existing contacts.

| Plan | Price | Contacts/mo |
| - | - | - |
| Free | \$0/mo | 1,000 |
| Pro Marketing | \$40/mo | 5,000 |
| Pro Marketing | \$80/mo | 10,000 |
| Pro Marketing | \$120/mo | 15,000 |
| Pro Marketing | \$180/mo | 25,000 |
| Pro Marketing | \$250/mo | 50,000 |
| Pro Marketing | \$450/mo | 100,000 |
| Pro Marketing | \$650/mo | 150,000 |
| Enterprise | Custom | Custom |

## Domains

Each plan includes a set number of domains:

| Plan | Domains |
| - | - |
| Free | 3 |
| Pro | 10 |
| Scale | 1,000 |
| Enterprise | Set by contract |

## Automations

All plans include 10,000 Automation Runs per month. Paid plans can continue beyond the included usage with pay-as-you-go billing at \$0.0015 per run. The Free plan includes 10,000 Automation Runs per month with no overage.

## Add-ons

Dedicated IPs are available for \$30/month on the Scale plan for customers sending more than 3,000 emails per day. Dedicated IPs include automatic warmup, monitoring, and autoscaling.

The domains add-on is available for \$20/month on paid transactional plans and adds 100 domains on top of the number included in your plan. See [How to add more domains](/docs/knowledge-base/how-to-add-more-domains).

## Annual plans

Annual subscriptions are available for Enterprise plans. [Book time with our sales team to learn more.](https://resend.com/enterprise)


# Which sending feature do you need?
Source: https://resend.com/docs/knowledge-base/what-sending-feature-to-use

How to pick between our different sending features depending on your number of recipients and the nature of the message.

Resend allows you to send both **Transactional** and **Marketing** emails.

## The difference between Transactional and Marketing emails

### Transactional emails

A **Transactional email** is a message triggered by a user action or required for legal compliance. These emails are essential communications that users **cannot unsubscribe** from. Common examples include:

* Order confirmations
* Password reset emails
* Account notifications

Typically, transactional emails are **1-to-1** messages sent in response to a specific event.

### Marketing emails

A **Marketing email** is any email that is not transactional. These can be **promotional**, **informative**, or **general communication** messages.

Marketing emails are regulated by laws like **CAN-SPAM** (US) and **CASL** (Canada), and **recipients must have the option to unsubscribe**.

Examples of marketing emails:

* Promotional offers and discounts
* Newsletters
* Product updates

Marketing emails can be **1-to-1** (e.g., abandoned cart reminders) or **1-to-many** (e.g., newsletters).

## Transactional vs Marketing: Which to Choose

While not exhaustive, here's a table listing different examples of emails and the most appropriate type for each example.

| Type of Message | Type of Recipient | Transactional | Marketing |
| - | - | - | - |
| Order confirmation | Single | ✓ | ⨯ |
| Password reset | Single | ✓ | ⨯ |
| Abandoned cart | Single | ⨯ | ✓ |
| Newsletter | Multiple | ⨯ | ✓ |
| Promotional offer | Multiple | ⨯ | ✓ |

## How to send an email with Resend

### How to send a Transactional email

You can send a Transactional email using:

* Our [Send Email API](/docs/api-reference/emails/send-email)
* Our [Batch Send API](/docs/api-reference/emails/send-batch-emails) (send up to 100 transactional emails in one API call)

### How to send a Marketing email

You can send Marketing emails using:

* [Resend no-code Editor](/docs/dashboard/broadcasts/introduction) – a collaborative interface for designing emails
* [Broadcast API](/docs/api-reference/broadcasts/create-broadcast) – for programmatic sending


# What's the difference between Opportunistic TLS vs Enforced TLS?
Source: https://resend.com/docs/knowledge-base/whats-the-difference-between-opportunistic-tls-vs-enforced-tls

Understand the different TLS configurations available.

Resend supports TLS 1.2, TLS 1.1 and TLS 1.0 for TLS connections.

There are two types of TLS configurations available:

* Opportunistic TLS
* Enforced TLS

## What is Opportunistic TLS?

Opportunistic TLS means that Resend always attempts to make a secure connection to the receiving mail server.

If the receiving server does not support TLS, the fallback is sending the message unencrypted.

## What is Enforced TLS?

Enforced TLS means that the email communication must use TLS no matter what.

If the receiving server does not support TLS, the email will not be sent.

## Is Enforced TLS better than Opportunistic TLS?

One strategy is not necessarily better than the other.

The decision is less about one option being safe and the other being unsafe, and more about one option being safe and the other being safer.

When you have Enforced TLS enabled, you might see an increase in bounce rates because some outdated mail servers do not support TLS.

So it's important to understand the different use cases for each configuration. If you're sending sensitive information like authentication emails, you might want to use Enforced TLS. If you're sending marketing emails, you might want to use Opportunistic TLS.

In simple terms, with Opportunistic TLS, delivery is more important than security. On the other hand, with Enforced TLS, security is more important than delivery.


# Why are my emails landing on the Suppression List?
Source: https://resend.com/docs/knowledge-base/why-are-my-emails-landing-on-the-suppression-list

Learn why your emails land on the Suppression List and how to remove them.

When sending to an email address results in a hard bounce or spam complaint, Resend places this address on the Suppression List. Future emails to addresses on the list will be marked as `suppressed` and won't be delivered until the address is removed.

> [!NOTE]
>
> We place emails on the Suppression List to protect domain reputation, both
> yours and ours. Sending an email to a known hard bounce recipient can damage
> domain reputation and affect email deliverability.

## Reasons emails are placed on the Suppression List

Here are some possible reasons an email address is placed on the Suppression List:

* The recipient's email address **contains a typo**.
* The recipient's email address **doesn't exist**.
* The recipient's email server has **permanently blocked delivery**.
* The recipient has marked a previous delivery as spam.

## What happens when you send to an address on the Suppression List

Whenever you send an email with Resend, the recipient is checked against the suppression list. If they're on it, the delivery is [suppressed](/docs/dashboard/emails/email-suppressions) to prevent damaging your sender reputation and our infrastructure.

Suppressed emails will appear with a `suppressed` status in your [Emails](https://resend.com/emails) dashboard:

![Email Suppression in Dashboard](https://mintcdn.com/resend/Nyu32IXsxRkmP92c/images/email-suppression-visibility-1.png?fit=max\&auto=format\&n=Nyu32IXsxRkmP92c\&q=85\&s=a40d291604cd8ddcc40f962e0b488da6)

## View suppression details

You can view the reason an email was suppressed on the [Emails](https://resend.com/emails) page:

1. Open the [Emails](https://resend.com/emails) page and search for the recipient's email address in question.
2. Click on the email to view its details.
3. The suppression details will show suggested fixes to help you resolve the issue.

<video />

## Removing an email address from the Suppression List

You may be able to send a message to the same recipient in the future if the issue that caused the original bounce or complaint is resolved and the email address is removed from the Suppression List.

> [!WARNING]
>
> Remember, if you do not address the issue that caused the email to bounce, the
> email address will return to the Suppression List the next time you attempt to
> send to it.

To remove your recipient from the Suppression List, click on the suppressed email in the [emails dashboard](https://resend.com/emails), and click **Remove from suppression list**.


# Why and when to use Topics?
Source: https://resend.com/docs/knowledge-base/why-use-topics

Learn when to use Topics to improve deliverability and give recipients control over their email preferences.

When you send an email, you make one primary decision: **who is this for?** Those recipients (a person, a list, or a Segment) are the core of sending. By default, everyone in that recipient group receives the message, but not everyone in that group may want that message.

Topics give recipients a way to say "don't send me this kind of email" without unsubscribing from everything. Think of Topics as **contracts with your recipients**: a promise that if they opt out of a content type, you'll respect it.

Topics don't define who receives a message. They **define who asked not to receive that message**. This guide explains why Topics matter for deliverability, when to use them, and how they differ from Segments.

## Why Topics improve deliverability

Deliverability focuses on landing in the inbox instead of the spam folder. And *recipient engagement* is a key factor in deliverability. Mailbox providers like Gmail and Outlook track whether people open, click, or mark your emails as spam.

When you send all your marketing emails to everyone on your list, a subsection of your recipients will not engage with your content. This leads to:

* **Lower open rates**: recipients ignore emails that don't interest them
* **Higher spam complaints**: frustrated recipients mark emails as spam instead of unsubscribing
* **Decreased sender reputation**: mailbox providers see low engagement and filter your emails to spam

Topics give your recipients agency, and they give you signals. When a recipient says "stop sending promotional emails," the system honors that request while continuing to send them content they do want. Topics let them decline one without losing the other.

## Without topics: global unsubscribe

Without Topics, your unsubscribe page offers only one option: **unsubscribe from everything**. This is a blunt instrument. Many recipients who would have gladly kept receiving some of your content will unsubscribe entirely because they received one too many emails about something they didn't want.

With Topics, recipients can say "no" to specific content types while staying connected to what they value. You retain more engaged subscribers.

## When to use Topics

Topics are most valuable when you send **multiple types of marketing content** to the same audience. Consider using Topics if you send:

| Topic Example | Description |
| - | - |
| **Newsletter** | Regular updates, articles, or curated content |
| **Product Updates** | New features, releases, and announcements |
| **Promotions** | Discounts, sales, and special offers |
| **Events** | Webinars, conferences, and meetups |
| **Tips & Tutorials** | Educational content and how-to guides |

## When you might not need Topics

If you only send one type of marketing email (for example, a monthly newsletter and nothing else), Topics add complexity without much benefit. In that case, a simple subscribe/unsubscribe model is sufficient.

## Topics vs Segments: key differences

Topics and Segments serve fundamentally different purposes. Understanding this distinction is key to using them effectively.

| Aspect | Topics | Segments |
| - | - | - |
| **Who controls it** | Your recipients | You (the sender) |
| **Visibility** | Shown on the unsubscribe page | Internal only (recipients never see them) |
| **Purpose** | Let users manage their preferences | Organize contacts for targeted sending |
| **Example** | "Newsletter", "Product Updates" | "Enterprise customers", "Free trial users" |

## How Segments and Topics work together

Think of Segments as **who you're sending to** and Topics as **what you're sending**.

When you send a Broadcast:

1. You choose a **Segment** as your recipients (your sender intent).
2. You label the content with a **Topic** (so the system can respect recipient preferences).
3. Everyone in the Segment receives the message, **except** those who opted out of that Topic.

For example, you might send a product announcement to your "Enterprise Customers" Segment, labeled with the "Product Updates" Topic. Recipients who previously said "don't send me product updates" are automatically excluded.

**Segments are for targeting. Topics are for protecting preferences.** They work together without competing.

## Customizing your unsubscribe page

When a recipient clicks the unsubscribe link in a Broadcast, they see a preference page showing your public Topics. This page is fully customizable to match your brand.

You can customize:

* **Title and description**
* **Logo**
* **Background color, text color, and accent color**

A branded unsubscribe page looks more professional and trustworthy, which can encourage recipients to adjust their preferences rather than unsubscribe entirely.

Learn more about [customizing your unsubscribe page](/docs/dashboard/settings/unsubscribe-page).

> [!NOTE]
>
> Pro plan users or higher can remove the "Powered by Resend" footer from the
> unsubscribe page.

## Opt-in vs Opt-out Topics

When creating a Topic, choose between two default subscription behaviors:

* **Opt-in (default)**: All contacts receive emails for this Topic unless they explicitly unsubscribe (applies retroactively to all contacts)
* **Opt-out**: Contacts do NOT receive emails for this Topic unless they explicitly subscribe

Use **Opt-in** for content that's broadly relevant to your audience (like product updates). Use **Opt-out** for niche content that only some users will want (like a beta program or developer-focused updates).

> [!WARNING]
>
> You cannot change the default subscription type after creating a Topic.

## Public vs Private Topics

When creating a Topic, you can set its visibility:

* **Public**: All contacts see this Topic on the unsubscribe page
* **Private**: Only contacts who are opted in to the Topic can see it

Private Topics are useful for exclusive content, like a beta program or VIP announcements, where you don't want to advertise the Topic to everyone.

## Best practices for Topics

### Keep it simple

Don't create too many Topics. Recipients get overwhelmed when faced with a long list of checkboxes. Aim for 3–5 distinct content types that clearly communicate what the recipient will receive.

### Use clear, descriptive names

Topic names must be immediately understandable. "Newsletter" and "Product Updates" are clear. "Category A" and "Misc" are not.

### Add descriptions

The optional description field helps recipients understand the topic. Use it to set expectations about frequency and content.

### Always label your Broadcasts with a Topic

Whenever you send a Broadcast, label it with a Topic. This ensures:

1. Recipients who declined that content type won't receive the email.
2. If someone unsubscribes, they can opt out of that Topic only, rather than unsubscribe from all your emails.

> [!NOTE]
>
> If you send a Broadcast without a Topic and someone unsubscribes, they'll be
> unsubscribed from all your emails. Labeling your content protects both you and
> your recipients.

## Getting started with Topics

1. [Create your Topics](/docs/dashboard/topics/introduction) in the Resend dashboard
2. [Customize your unsubscribe page](/docs/dashboard/settings/unsubscribe-page) with your branding
3. Use [Segments](/docs/dashboard/segments/introduction) to define who you're sending to
4. When sending [Broadcasts](/docs/dashboard/broadcasts/introduction), always label them with a Topic

By using Segments for targeting and Topics for respecting preferences, you send to the right people while honoring those who said no, improving engagement and protecting your sender reputation.


# Send emails with Leap and Resend
Source: https://resend.com/docs/leap-new-integration

Learn how to add the Resend integration to your Leap.new project.

[Leap](https://leap.new) is a platform for building full-stack web and mobile apps via chat.

## Guide

**1. Ask Leap to add Resend**

You can add Resend in a Leap project by asking the chat to add email sending with Resend.

**Example prompt**

```
When someone fills out the contact form, send an email using Resend.
```

**2. Add your Resend API key**

To use Resend with Leap, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

Leap will prompt you to set a secret value on the Infrastructure page. Paste your key value and click **Update secret**.

![adding the Resend integration to a leap.new chat](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/leap-new-integration.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=d1c68aa7b6144ffcd8ee2793cdebe67d)

> [!NOTE]
>
> Learn more about the Resend integration in the [Leap
> documentation](https://docs.leap.new/integrations/resend).

**3. Add a custom domain to your Resend account**

By default, you can only send emails to your own email address.

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](/docs/add-a-domain).
2. Add the custom domain to the `from` field in the `resend` function in Leap (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/docs/dashboard/domains/introduction).


# Send emails with Lovable and Resend
Source: https://resend.com/docs/lovable-integration

Learn how to add the Resend integration to your Lovable project.

[Lovable](https://lovable.dev) is a platform for building web sites, tools, apps, and projects via chat. You can add Resend in a Lovable project by asking the chat to add email sending with Resend.

If you prefer to watch a video, check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/0gw693uZt0w)

## Guide

**1. Add your Resend API key**

To use Resend with Lovable, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

Lovable may integrate Resend in a few different ways:

* Use the Supabase integration to store the API key **(highly recommended)**
* Ask users to provide their own API key
* Add the API key directly in the code

You may need to prompt Lovable to store the API key for Resend using Supabase. Clicking **Add API key** will open a modal where you can add the API key.

![adding the Resend integration to a Lovable chat](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/lovable-integration.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=c071ba3ae671bc6cafd8dfd43e12772d)

> [!NOTE]
>
> At the time of writing, Lovable does not securely handle API keys
> independently. Instead, it uses the [Supabase integration to store
> secrets](https://docs.lovable.dev/integrations/supabase#storing-secrets-api-keys-%26-config).

**2. Add a custom domain to your Resend account**

By default, you can only send emails to your own email address.

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](/docs/add-a-domain).
2. Add the custom domain to the `from` field in the `resend` function in Lovable (or ask the chat to update these fields).

> [!NOTE]
>
> By default, Lovable deploys using the test domain `resend.dev`. Once your custom domain is verified, the function does not automatically redeploy or update the sender address.
>
> You’ll need to ask Lovable to manually update the `From` email to use your verified domain and then redeploy the function so the changes take effect.

Get more help adding a custom domain in [Resend's documentation](/docs/dashboard/domains/introduction).


# MCP Server
Source: https://resend.com/docs/mcp-server

Connect your AI agent to Resend using the hosted MCP server.

MCP is an open protocol that standardizes how applications provide context to LLMs. Among other benefits, it provides LLMs tools to act on your behalf. Resend offers both a [remote MCP server](#remote-mcp-server) and a [local MCP server](#local-mcp-server).

[YouTube video player](https://www.youtube.com/embed/GjLb4hFo2qg)

## Remote MCP Server

Resend hosts the MCP server at:

```
https://mcp.resend.com/mcp
```

Connect any MCP client that supports remote servers (Streamable HTTP). There's nothing to install and no local process to run, which makes it the best option for web-based clients like Claude and hosted agent platforms.

When you connect, your client opens a browser window to log in to Resend and approve access using OAuth.

The [Resend plugin](https://github.com/resend/resend-skills) follows the [Agent Plugins](https://agent-plugins.org) spec. On clients that install that plugin, it adds this remote MCP server and the adjacent [Resend skills](/docs/resend-skill) together. `plugin.json` identifies the plugin, `skills/` holds the skills, and `mcp.json` points at `https://mcp.resend.com/mcp`.

Each tab below matches the install on that client's page at resend.com.

> [tab] Claude
>
> Connect Resend in one click from the [connector directory](https://claude.ai/directory/connectors/resend). The connector installs the MCP server and every Resend skill.
>
> To install only the MCP server, add it manually in Claude (web or desktop) from **Settings** > **Connectors** > **Add custom connector**:
>
> ```
> https://mcp.resend.com/mcp
> ```
>
> See the [Claude page](https://resend.com/claude).

> [tab] Copilot
>
> To use GitHub Copilot in VS Code, add the following to your `settings.json`:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcp": {
>     "servers": {
>       "resend": {
>         "type": "http",
>         "url": "https://mcp.resend.com/mcp"
>       }
>     }
>   }
> }
> ```
>
> Install the skills separately:
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> npx skills add resend/resend-skills
> ```
>
> See the [GitHub Copilot page](https://resend.com/github-copilot).

> [tab] Claude Code
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> claude plugin install resend@claude-plugins-official
> ```
>
> Then run `/mcp` in Claude Code and select **resend** to complete the OAuth login. The plugin installs the remote MCP server and every [Resend skill](/docs/resend-skill).
>
> See the [Claude Code page](https://resend.com/claude-code).

> [tab] Cursor
>
> Run `/add-plugin resend` in Cursor's chat to install the official plugin. It follows the Agent Plugins spec and installs the remote MCP server and every Resend skill.
>
> To connect only the MCP server, open the command palette and choose "Cursor Settings" > "MCP" > "Add new global MCP server".
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "url": "https://mcp.resend.com/mcp"
>     }
>   }
> }
> ```
>
> See the [Cursor page](https://resend.com/cursor).

> [tab] Codex
>
> Install the [Resend plugin](https://chatgpt.com/plugins/plugin_asdk_app_6a3c407853888191beddc2151c2b6f8b?open_in_codex) in one click. It follows the Agent Plugins spec and installs the remote MCP server and every Resend skill.
>
> To connect the MCP server on its own, use the Codex CLI:
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> codex mcp add resend --url https://mcp.resend.com/mcp
> ```
>
> See the [Codex page](https://resend.com/codex).

> [tab] Hermes
>
> Install the official Resend plugin. One command adds the remote MCP server and every Resend skill.
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> hermes plugins install resend/resend-skills --enable
> ```
>
> Store `RESEND_API_KEY` so Hermes can send on your behalf. You will be prompted on first use.
>
> See the [Hermes page](https://resend.com/hermes).

> [tab] Grok Bot
>
> In Grok Bot, install the Resend plugin. That adds every Resend skill.
>
> ```
> /install-plugin resend
>
> # Then add RESEND_API_KEY so Grok Bot can send on your behalf.
> ```
>
> See the [Grok Bot page](https://resend.com/grokbot).

> [tab] OpenClaw
>
> Add the remote MCP server, then sign in:
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> openclaw mcp add resend --url https://mcp.resend.com/mcp --transport streamable-http
> openclaw mcp login resend
> ```
>
> Ask OpenClaw to install the skills:
>
> ```
> Install the Resend skills: https://github.com/resend/resend-skills
> ```
>
> See the [OpenClaw page](https://resend.com/openclaw). For an inbox, see the [OpenClaw guide](/docs/openclaw-guide).

> [tab] OpenCode
>
> Add to your `opencode.json` config:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "$schema": "https://opencode.ai/config.json",
>   "mcp": {
>     "resend": {
>       "type": "remote",
>       "url": "https://mcp.resend.com/mcp",
>       "enabled": true
>     }
>   }
> }
> ```

> [tab] Antigravity
>
> Add this to your `~/.gemini/config/mcp_config.json` file:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "serverUrl": "https://mcp.resend.com/mcp"
>     }
>   }
> }
> ```

> [tab] Gemini CLI
>
> Add this to your `~/.gemini/settings.json` file:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "httpUrl": "https://mcp.resend.com/mcp"
>     }
>   }
> }
> ```

> [tab] Devin
>
> In Devin, open **Settings** > **Connections** > **MCP Servers** and click **Add a custom MCP**. See the [Devin guide](/docs/guides/devin) for the full step-by-step.
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "transport": "HTTP",
>       "url": "https://mcp.resend.com/mcp"
>     }
>   }
> }
> ```

> [tab] Zed
>
> Add this to your Zed `settings.json`:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "context_servers": {
>     "resend": {
>       "url": "https://mcp.resend.com/mcp"
>     }
>   }
> }
> ```

> [tab] Warp
>
> In Warp's Settings, navigate to **Agents** > **MCP servers**, and click **+ Add** to add a new server.
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "resend": {
>     "serverUrl": "https://mcp.resend.com/mcp"
>   }
> }
> ```

> [tab] fx
>
> [fx](https://fx.sh) is a tiny, open, native coding agent from Vercel Labs. Install it, then add Resend as an HTTP server:
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> curl -fsSL https://fx.sh/setup.sh | bash
> fx mcp add --transport http resend https://mcp.resend.com/mcp
> ```
>
> fx completes the OAuth login the first time it connects. Inside the fx shell, the equivalent is `/mcp add --transport http resend https://mcp.resend.com/mcp`.

***

*If your client runs somewhere a browser login isn't possible* (a server, CI, or a headless agent), pass a [Resend API key](https://resend.com/api-keys) as a Bearer token instead of using OAuth.

> [tab] Claude Code
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> claude mcp add --transport http resend https://mcp.resend.com/mcp --header "Authorization: Bearer re_xxxxxxxxx"
> ```

> [tab] JSON config
>
> For clients configured with JSON (Cursor, Zed, and others), add an `Authorization` header:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "url": "https://mcp.resend.com/mcp",
>       "headers": {
>         "Authorization": "Bearer re_xxxxxxxxx"
>       }
>     }
>   }
> }
> ```

## Local MCP Server

The hosted server runs the same open-source code that's available on NPM as [`resend-mcp`](https://github.com/resend/resend-mcp). If you prefer to run the server yourself, you can integrate it into any supported MCP client using `npx`. You'll need to:

* [Create an API key](/docs/create-an-api-key)
* [Verify your domain](/docs/add-a-domain)

The local server supports two transport modes: **stdio** (default) and **HTTP**.

Choose your preferred mode and client below to get started. Remember to replace `re_xxxxxxxxx` with your actual API key.

### Stdio Transport (Default)

> [tab] Claude Desktop
>
> Open Claude Desktop settings > "Developer" tab > "Edit Config".
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "command": "npx",
>       "args": ["-y", "resend-mcp"],
>       "env": {
>         "RESEND_API_KEY": "re_xxxxxxxxx"
>       }
>     }
>   }
> }
> ```

> [tab] Copilot
>
> To use GitHub Copilot in VS Code, add the following to your `settings.json`:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcp": {
>     "servers": {
>       "resend": {
>         "command": "npx",
>         "args": ["-y", "resend-mcp"],
>         "env": {
>           "RESEND_API_KEY": "re_xxxxxxxxx"
>         }
>       }
>     }
>   }
> }
> ```

> [tab] Claude Code
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> claude mcp add resend -e RESEND_API_KEY=re_xxxxxxxxx -- npx -y resend-mcp
> ```

> [tab] Cursor
>
> Open the command palette and choose "Cursor Settings" > "MCP" > "Add new global MCP server".
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "command": "npx",
>       "args": ["-y", "resend-mcp"],
>       "env": {
>         "RESEND_API_KEY": "re_xxxxxxxxx"
>       }
>     }
>   }
> }
> ```

> [tab] Codex
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> codex mcp add resend \
>   --env RESEND_API_KEY=re_xxxxxxxxx \
>   -- npx -y resend-mcp
> ```

> [tab] OpenCode
>
> Add to your `opencode.json` config:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "$schema": "https://opencode.ai/config.json",
>   "mcp": {
>     "resend": {
>       "type": "local",
>       "command": ["npx", "-y", "resend-mcp"],
>       "enabled": true,
>       "environment": {
>         "RESEND_API_KEY": "re_xxxxxxxxx"
>       }
>     }
>   }
> }
> ```

> [tab] Antigravity
>
> Add this to your `~/.gemini/config/mcp_config.json` file:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "command": "npx",
>       "args": ["-y", "resend-mcp"],
>       "env": {
>         "RESEND_API_KEY": "re_xxxxxxxxx"
>       }
>     }
>   }
> }
> ```

> [tab] Gemini CLI
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "command": "npx",
>       "args": ["-y", "resend-mcp"],
>       "env": {
>         "RESEND_API_KEY": "re_xxxxxxxxx"
>       }
>     }
>   }
> }
> ```

> [tab] Devin
>
> In Devin, open **Settings** > **Connections** > **MCP Servers** and click **Add a custom MCP**. See the [Devin guide](/docs/guides/devin) for the full step-by-step.
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "command": "npx",
>       "args": ["-y", "resend-mcp"],
>       "env": {
>         "RESEND_API_KEY": "re_xxxxxxxxx",
>         "SENDER_EMAIL_ADDRESS": "onboarding@resend.dev"
>       }
>     }
>   }
> }
> ```

> [tab] Zed
>
> Add this to your Zed `settings.json`:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "context_servers": {
>     "resend": {
>       "command": "npx",
>       "args": ["-y", "resend-mcp"],
>       "env": {
>         "RESEND_API_KEY": "re_xxxxxxxxx"
>       }
>     }
>   }
> }
> ```

> [tab] Warp
>
> In Warp's Settings, navigate to **Agents** > **MCP servers**, and click **+ Add** to add a new server.
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "resend": {
>     "command": "npx",
>     "args": ["-y", "resend-mcp"],
>     "env": {
>       "RESEND_API_KEY": "re_xxxxxxxxx"
>     }
>   }
> }
> ```

> [tab] fx
>
> Add this to your `~/.fx/mcp.json` file:
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcp": {
>     "resend": {
>       "type": "stdio",
>       "command": ["npx", "-y", "resend-mcp"],
>       "environment": {
>         "RESEND_API_KEY": "re_xxxxxxxxx"
>       }
>     }
>   }
> }
> ```

### HTTP Transport

Run the server over HTTP for remote or web-based integrations. In HTTP mode, each client authenticates by passing their Resend API key as a Bearer token in the `Authorization` header.

Start the server:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx -y resend-mcp --http --port 3000
```

The server will listen on `http://127.0.0.1:3000` and expose the MCP endpoint at `/mcp` using Streamable HTTP.

> [tab] Claude Code
>
> ```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
> claude mcp add resend --transport http http://127.0.0.1:3000/mcp --header "Authorization: Bearer re_xxxxxxxxx"
> ```

> [tab] Cursor
>
> Open the command palette and choose "Cursor Settings" > "MCP" > "Add new global MCP server".
>
> ```json theme={"theme":{"light":"github-light","dark":"vesper"}}
> {
>   "mcpServers": {
>     "resend": {
>       "url": "http://127.0.0.1:3000/mcp",
>       "headers": {
>         "Authorization": "Bearer re_xxxxxxxxx"
>       }
>     }
>   }
> }
> ```

You can also set the port via the `MCP_PORT` environment variable:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
MCP_PORT=3000 npx -y resend-mcp --http
```

### Options

You can pass additional arguments to configure the local server:

* `--key`: Your Resend API key (stdio mode only, since HTTP mode uses the Bearer token from the client)
* `--sender`: Default sender email address from a verified domain
* `--reply-to`: Default reply-to email address (can be specified multiple times)
* `--http`: Use HTTP transport instead of stdio (default: stdio)
* `--port`: HTTP port when using `--http` (default: 3000, or `MCP_PORT` env var)

**Environment variables:**

* `RESEND_API_KEY`: Your Resend API key (required for stdio, optional for HTTP since clients pass it via Bearer token)
* `SENDER_EMAIL_ADDRESS`: Default sender email address from a verified domain (optional)
* `REPLY_TO_EMAIL_ADDRESSES`: Comma-separated reply-to email addresses (optional)
* `MCP_PORT`: HTTP port when using `--http` (optional)

> [!NOTE]
>
> If you don't provide a sender email address, the MCP server will ask you to
> provide one each time you call the tool.

## MCP Server tools

Resend's MCP server gives your AI agent native access to the full Resend platform through a single integration. You can manage all aspects of your email infrastructure using natural language.

* **Emails**: Send, list, get, cancel, update, and batch send emails. Supports HTML, plain text, attachments (local file, URL, or base64), CC/BCC, reply-to, scheduling, tags, and topic-based sending.
* **Received Emails**: List and read inbound emails. List and download received email attachments.
* **Inboxes**: Create, list, get, update, and remove inboxes. Search their threads, and manage threads, thread emails (get, reply, forward), labels, and drafts (create, update, send). Inboxes is only available on the [remote MCP server](#remote-mcp-server), not the local `resend-mcp` package.
* **Templates**: Create, list, get, update, publish, duplicate, and remove email templates. Supports composing template content and `{{{VARIABLE}}}` placeholders.
* **Contacts**: Create, list, get, update, and remove contacts. Manage segment memberships, topic subscriptions, and CSV contact imports. Supports custom contact properties.
* **Broadcasts**: Create, send, list, get, update, and remove broadcast campaigns. Supports scheduling, personalization placeholders, and preview text.
* **Automations**: Create, list, get, update, duplicate, and remove automations. Review the runs of an automation.
* **Events**: Send events to trigger automations for a contact. Create, update, and remove event definitions.
* **Domains**: Create, list, get, update, remove, and verify sender domains. Configure tracking, TLS, and sending/receiving capabilities. Create and verify domain claims.
* **Segments**: Create, list, get, and remove audience segments.
* **Topics**: Create, list, get, update, and remove subscription topics.
* **Contact Properties**: Create, list, get, update, and remove custom contact attributes.
* **API Keys**: Create, list, and remove API keys.
* **Webhooks**: Create, list, get, update, and remove webhooks for event notifications.
* **Logs**: List and inspect API request logs, including full request and response bodies.
* **Editor**: Connect to (and disconnect from) the visual editor in the Resend dashboard, and read a draft's content while collaborating on broadcasts and templates.

Here are some real examples of what your agent can do with these tools:

* Turn a [Paper design](/docs/guides/paper) into a ready-to-send [Template](/docs/dashboard/templates/introduction) or [Broadcast](/docs/dashboard/broadcasts/introduction)
* [Bulk import contacts from a CSV](/docs/dashboard/contacts/add-contacts#add-contacts-by-uploading-a-csv), upserting or skipping duplicates, and organize them into [Segments](/docs/dashboard/segments/introduction)
* Build [Automations](/docs/dashboard/automations/introduction) that send emails when a contact is created, updated, or triggers a [custom event](/docs/dashboard/automations/custom-events)
* Read and triage [inbound email](/docs/dashboard/receiving/introduction), download attachments, and send replies
* Schedule, reschedule, and cancel [scheduled emails](/docs/dashboard/emails/schedule-email)
* Debug failed API requests by inspecting the [request logs](/docs/dashboard/logs/introduction)


# OpenClaw Guide
Source: https://resend.com/docs/openclaw-guide

Learn how to give your AI agent an inbox to send and receive emails.

## Why give your agent an inbox

Giving your agent an inbox enables it to:

* **Sign up for its own accounts** to GitHub, hosting platforms, and more, so you don't need to share your own credentials.
* **Process attachments** (such as receipts and invoices) and act accordingly
* **Receive newsletters**, parse them, and send the most important information to you
* **Send you daily reports and digests**
* **Send and receive emails**, and reply inside each conversation thread

## How to set up an inbox for OpenClaw

### Step 1: Connect Resend

Add the remote MCP server, then sign in. This is the same setup as the [OpenClaw page](https://resend.com/openclaw).

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
openclaw mcp add resend --url https://mcp.resend.com/mcp --transport streamable-http
openclaw mcp login resend
```

Ask your agent to install the skills:

```
Let's get you set up with an email inbox! Install the resend-skills from https://github.com/resend/resend-skills and review them before continuing.
```

> [!TIP]
>
> Giving your agent the GitHub link helps it to install the latest version of
> the skill since OpenClaw skills operate differently than traditional agent
> skills.

Your agent may also benefit from installing the [Resend CLI](/docs/cli).

### Step 2: Get an API key

Your agent will ask you to create an API key.

> [!TIP]
>
> Your API key will be scoped to the team that's currently selected. If you'd
> like to sandbox your agent, create a new team just for your agent.

**1. Open the API Keys dialog**

Navigate to the [API Keys](https://resend.com/api-keys) page in Resend and
click **Create API Key**.

**2. Choose a name and permission scope**

Choose a name for your API key and ensure **Full access** is selected as the
permission scope.

**3. Create the API key**

Click **Add** to create the API key, and copy it to your clipboard.

We recommend not pasting API keys into the chat. Instead, use one of these two methods:

1. SSH into your agent's machine and **store the API key in an `.env` file**.
2. **Store the API key in a password manager** like 1Password, and give your agent access to its own vault. This can be done using a [1Password Service Account](https://developer.1password.com/docs/service-accounts/) on team plans.

### Step 3: Verify a domain

Next, your agent needs to know the email address it will use to send and receive emails. Strongly consider using a [subdomain](/docs/dashboard/domains/introduction#subdomains) (`agent.example.com`) instead of the root domain (`example.com`), especially if you want to receive emails.

You can also use the [Resend CLI](/docs/cli) to verify a domain, although you will need to manually add the DNS records to your DNS provider.

**1. Add a domain**

Navigate to the [Domains tab](https://resend.com/domains) and click **Add
Domain**.

**2. Select a subdomain and region**

Add the subdomain you want to verify, and choose the region that's closest
to your agent.

You may see one of three options:

* **Auto Configure**: This will automatically configure the DNS records for you if your provider supports it.
* **Go to (provider)**: This will take you to the provider's website to add the DNS records manually if we can detect your provider.
* **I've added the records**: If we cannot detect your provider, you can manually add the DNS records by opening your DNS provider's website.

If you want only to send emails with your agent, add the DNS records and confirm. If you want to also receive emails, continue to the next step to enable receiving (for autoconfigure, you can add receiving after you autoconfigure).

**3. Enable receiving**

**Receiving** allows your agent to receive emails at your domain, rather
than simply sending. Scroll to the bottom of the page and toggle the switch
to **On**.

**4. Add the DNS records to your domain**

Add the DNS records to your domain's DNS provider. For
more guidance, see our [guides on adding DNS records to various
providers](knowledge-base/introduction#dns-guides).

**5. Wait for verification**

Wait for the domain to be verified. This can take up to 72 hours, but is
typically finished within a few minutes.

> [!TIP]
>
> For a more in-depth guide on domain verification, see our [guide on verifying
> a domain](/docs/dashboard/domains/introduction).

Once your domain is verified in Resend, you can use it to send (and receive) emails with your agent. Add the email address to your agent's memory and tell it to send you a test email to your own email address.

### Step 4: Create your agent's inbox

An [inbox](/docs/api-reference/inboxes/create-inbox) gives your agent its own address on your domain. It groups each conversation into a thread, so your agent can reply in context.

Ask your agent to create it:

```
Create a Resend inbox for agent@agent.example.com using the agent email inbox agent skill.
```

> [!NOTE]
>
> If your plan has no inbox available, the skill falls back to Resend
> [Receiving](/docs/dashboard/receiving/introduction) with the `email.received`
> event. The security levels stay the same.

### Step 5: Use webhooks to receive emails

At this point, your agent can send emails, but **it can't receive emails yet**.

To receive, you need to set up a webhook.

**1. Ask your agent to set up a webhook server**

Your agent should be equipped to do this using the Resend skill. Prompt it to get started:

```
I want you to be able to receive emails, too. Let's set up a webhook to receive emails at my domain using the agent email inbox agent skill.
```

**2. Set up a tunnel**

Your agent should spin up a local server and suggest using a tunneling tool
to expose it to the internet. We recommend [Tailscale
Funnel](https://tailscale.com/kb/1223/funnel):

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
tailscale funnel 3000
```

This gives your agent a stable public URL at
`https://hostname.tailnet-name.ts.net`.

**3. Give your agent access to secrets securely**

When your agent asks for webhook signing secrets, give it access securely using one of the methods described in [Step 2: Get an API key](#step-2-get-an-api-key). Don't paste them directly into the chat.

**4. Add the webhook to Resend**

Ask your agent to register the webhook with Resend:

```
Let's add a webhook to Resend using the server you just built. Use the inbox.email.received event, as instructed by the resend-skills agent skill, and securely save the returned webhook signing secret.
```

**5. Test receiving an email**

Send your agent a test email and ask it to check its inbox.

Your webhook server might look something like this:

```js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

// Security: strict allowlist
const ALLOWED_SENDERS = ['your@email.com'];

// `from` can be `Name <address>`, so compare the address only
const senderAddress = (from) => {
  const match = from.match(/<([^<>]+)>\s*$/);
  return (match ? match[1] : from).trim().toLowerCase();
};

async function handler(req) {
  const payload = await req.text();

  const id = req.headers.get('svix-id');
  const timestamp = req.headers.get('svix-timestamp');
  const signature = req.headers.get('svix-signature');

  if (!id || !timestamp || !signature) {
    return new Response('Missing headers', { status: 400 });
  }

  const event = resend.webhooks.verify({
    payload,
    headers: { id, timestamp, signature },
    webhookSecret: process.env.RESEND_WEBHOOK_SECRET,
  });

  if (event.type === 'inbox.email.received') {
    const { inbox_id, thread_id, email_id, email } = event.data;

    // Security check
    if (!email || !ALLOWED_SENDERS.includes(senderAddress(email.from))) {
      return new Response('OK', { status: 200 });
    }

    // Get full email
    const { data: fullEmail } = await resend.inboxes.threads.emails.get({
      inboxId: inbox_id,
      threadId: thread_id,
      emailId: email_id,
    });

    // Notify user instantly
    await notifyUser(fullEmail);
  }

  // Receiving fallback, when your plan has no inbox available
  if (event.type === 'email.received') {
    if (!ALLOWED_SENDERS.includes(senderAddress(event.data.from))) {
      return new Response('OK', { status: 200 });
    }

    const { data: fullEmail } = await resend.emails.receiving.get(
      event.data.email_id,
    );

    await notifyUser(fullEmail);
  }

  return new Response('OK', { status: 200 });
}
```

> [!NOTE]
>
> For more help working with inbox emails, including how to reply in the thread,
> see [Reply to Thread Email](/docs/api-reference/inboxes/reply-thread-email).

### Step 6: Hook into OpenClaw's APIs for instant notifications

One of the benefits of using Resend over other tools is that you don't need to constantly ask your agent to check its inbox, or rely on cron jobs to check every so often. With Resend, you can use OpenClaw's Gateway API to be notified instantly when your agent receives an email.

**1. Ask your agent to hook into the Gateway API**

```text theme={"theme":{"light":"github-light","dark":"vesper"}}
Use the OpenClaw Gateway API to notify me instantly when you receive an email webhook call from Resend. Use the resend-skills agent skill for guidance.
```

**2. Test instant notifications**

Send your agent another test email. It should notify you instantly.

## Security considerations

Giving your agent an inbox is incredibly powerful, but it also comes with some security concerns. The risk of prompt injection via email is a real concern.

The Resend Skill [includes security guidelines](https://github.com/resend/resend-skills/blob/main/skills/agent-email-inbox/SKILL.md#security-levels). Use the leveled security approach below to decide which security level is right for your use case.

1. **Strict Allowlist**: Only allow emails from specific senders. **Recommended for most use cases**.
2. **Domain Allowlist**: Allow emails from any sender from a given domain (e.g. anyone from `example.com`).
3. **Content Filtering with Sanitization**: Accept emails from anyone, but sanitize content to remove potential injection attempts.
4. **Sandboxed Processing**: Process all emails but in a restricted context where the agent has limited capabilities.
5. **Human-in-the-Loop**: Process all emails but require human approval for each email.

In general, we recommend starting with the **Strict Allowlist** and gradually decreasing security if needed. Review additional security best practices in the [Resend Skill](https://github.com/resend/resend-skills/blob/main/skills/agent-email-inbox/SKILL.md#security-levels).

If you have any questions, please [contact support](https://resend.com/help).


# React Email Skill
Source: https://resend.com/docs/react-email-skill

Build HTML emails using React components with AI agents.

The React Email skill enables AI agents to build production-ready HTML emails using React components. It provides a modern development experience for creating responsive, cross-client compatible emails.

## Installation

Install the skill using the following command:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

## Advantages

* **Component-based email development**: Build emails using reusable React components for consistent, maintainable templates.
* **Brand-consistent styling with Tailwind**: Use Tailwind CSS to style emails with your brand's design system.
* **Multi-format rendering**: Automatically generate both HTML and plain text versions of your emails.
* **Email client compatibility handling**: Built-in support for rendering emails correctly across all major email clients.
* **Built-in preview server**: Preview your emails in real-time during development with hot reloading.

## Learn More

> [card] [View on GitHub](https://github.com/resend/react-email/tree/canary/skills)
>
> See the full source code and documentation.


# Send emails with Replit and Resend
Source: https://resend.com/docs/replit-integration

Learn how to add the Resend integration to your Replit project.

[Replit](https://replit.com/) is a platform for building sites and apps with AI. You can add Resend in a Replit project by asking the chat to add email sending with Resend.

**Example prompt**

```
When someone fills out the contact form, send an email using Resend.
```

Prefer watching a video? Check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/gXwFWFMcnnY)

## Guide

**1. Add a custom domain to your Resend account**

By default, you can only send emails to your own email address.

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](https://resend.com/domains).
2. Add the custom domain to the `from` field in the `resend` function in Replit (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/docs/dashboard/domains/introduction).

**2. Add your Resend API key and from address**

To use Resend with Replit, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

The from address is the email address that will be used to send emails. Use your custom domain you added in step 1 here (e.g., `hello@example.com`).

![adding the Resend integration to a Replit chat](https://mintcdn.com/resend/873NN72QQCCHs00J/images/replit-integration.png?fit=max\&auto=format\&n=873NN72QQCCHs00J\&q=85\&s=7c6dee645c882748990a7973150b252f)

> [!NOTE]
>
> Replit tracks the details of your Resend integration in the [Integrations
> page](https://replit.com/integrations).


# Resend Skill
Source: https://resend.com/docs/resend-skill

Send emails through the Resend API with AI agents.

The Resend skill enables AI agents to send emails through the Resend API using our official recommendations. It provides a streamlined interface for sending single and batch emails with built-in error handling and retry logic.

## Installation

This skill is part of the [resend-skills](https://github.com/resend/resend-skills) repository, which also includes the [Agent Email Inbox skill](/docs/agent-email-inbox-skill) for secure inbound email processing. When you run the install command, you'll be prompted to choose which skills to install.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
```

Clients that support the [Agent Plugins](https://agent-plugins.org) spec can install the same repository as a plugin. That install adds these skills and the [remote MCP server](/docs/mcp-server) together. The [MCP server docs](/docs/mcp-server#remote-mcp-server) list the install command for each supported client.

## Advantages

Build with our official recommendations for sending emails with Resend.

* **Single and batch email sending**: Send individual emails or batch up to 100 emails per request.
* **Built-in error handling and retry logic**: Automatic retries with exponential backoff for transient failures.
* **Idempotency key support**: Prevent duplicate sends with idempotency keys for safe retries.
* **Multi-language SDK support**: Works with Node.js, Python, Ruby, Go, and other supported SDKs.
* **Automatic activation for email tasks**: AI agents automatically use this skill when email sending is needed.

## Learn More

> [card] [Agent Email Inbox](/docs/agent-email-inbox-skill)
>
> Give your agent a secure inbox to receive and act on inbound emails.

> [card] [View on GitHub](https://github.com/resend/resend-skills)
>
> See the full source code and documentation.


# Official SDKs
Source: https://resend.com/docs/sdks

Open source client libraries for your favorite platforms.

## Official SDKs

> [card] [Node.js](https://github.com/resend/resend-node)
>
> github.com/resend/resend-node

> [card] [PHP](https://github.com/resend/resend-php)
>
> github.com/resend/resend-php

> [card] [Laravel](https://github.com/resend/resend-laravel)
>
> github.com/resend/resend-laravel

> [card] [Python](https://github.com/resend/resend-python)
>
> github.com/resend/resend-python

> [card] [Ruby](https://github.com/resend/resend-ruby)
>
> github.com/resend/resend-ruby

> [card] [Go](https://github.com/resend/resend-go)
>
> github.com/resend/resend-go

> [card] [Java](https://github.com/resend/resend-java)
>
> github.com/resend/resend-java

> [card] [Rust](https://github.com/resend/resend-rust)
>
> github.com/resend/resend-rust

> [card] [.NET](https://github.com/resend/resend-dotnet)
>
> github.com/resend/resend-dotnet

> [card] [Chat SDK Adapter](https://github.com/resend/resend-chat-sdk)
>
> github.com/resend/resend-chat-sdk

## Community SDKs

> [card] [Elixir](https://github.com/elixir-saas/resend-elixir)
>
> github.com/elixir-saas/resend-elixir

> [card] [NestJS](https://github.com/jiangtaste/nestjs-resend)
>
> github.com/jiangtaste/nestjs-resend

> [card] [Dart](https://github.com/coderaveHQ/dart_resend)
>
> github.com/coderaveHQ/dart\_resend

## OpenAPI

> [card] [OpenAPI](https://github.com/resend/resend-openapi)
>
> github.com/resend/resend-openapi


# Security
Source: https://resend.com/docs/security

An overview of Resend security features and practices.

## Governance

Resend establishes policies and controls, monitors compliance with those controls, and proves the security and compliance to third-party auditors.

Our policies are based on the following **foundational principles**:

> [card] Least Privilege
>
> Access should be limited to only those with a legitimate business needs,
> based on the principle of least privilege.

> [card] Consistency
>
> Security controls should be applied consistently across all areas of the
> enterprise.

> [card] Defense in Depth
>
> Security controls should be implemented and layered according to the
> principle of defense-in-depth.

> [card] Continuous Improvement
>
> The implementation of controls should be iterative, continuously improving
> effectiveness and decreasing friction.

### Compliance Standards

> [accordion] SOC 2 Type II
>
> Resend is SOC 2 Type II compliant. The audit was completed by Vanta & Advantage Partners.
> You can download a copy of the report on the [Documents](https://resend.com/settings/documents) page.

> [accordion] GDPR
>
> Resend is GDPR compliant. You can learn more about our [GDPR compliance](https://resend.com/security/gdpr) or view our [DPA](https://resend.com/legal/dpa).

## Data Protection

> [card] Data at rest
>
> All datastores are encrypted at rest. Sensitive collections and tables also
> use row-level encryption.

> [card] Data in transit
>
> Resend uses TLS 1.3 or higher everywhere data is transmitted over
> potentially insecure networks.

> [card] Data backup
>
> Resend backs-up all production data using a point-in-time approach. Backups
> are persisted for 7 days.

## Product Security

### Penetration testing

Resend engages with third-party firms to conduct penetration testing at least annually.

All areas of the Resend product and cloud infrastructure are in-scope for these assessments, and source code is fully available to the testers to maximize the effectiveness and coverage.

You can download the latest penetration test report on the [Documents](https://resend.com/settings/documents) page.

### Vulnerability scanning

Resend uses multiple vulnerability monitoring techniques including code-level scanning, dependency scanning, and security reviews to identify and remediate vulnerabilities.

Vulnerabilities are prioritized based on severity and risk, and are remediated according to the following schedule:

* Critical: 15 Days
* High: 30 Days
* Medium: 90 Day
* Low: 180 Days
* Informational: As needed

## Enterprise Security

> [card] Endpoint protection
>
> All company devices are equipped with anti-malware protection. Endpoint security alerts are monitored with 24/7/365 coverage. We use MDM software to enforce secure configuration of endpoints, such as disk encryption, screen lock configuration, and software updates.

> [card] Security education
>
> Resend provides comprehensive security training to all employees upon onboarding and annually.
>
> Resend's conducts threat briefings with employees to inform them of important security and safety-related updates that require special attention or action.

> [card] Identity and access management
>
> Resend employees are granted access to applications based on their role, and automatically deprovisioned upon termination of their employment. Further access must be approved according to the policies set for each application.
>
> Multi-factor authentication is required for all employees to access company applications.

## Responsible Disclosure

To report a vulnerability, please check the guidelines on the [Responsible Disclosure](https://resend.com/security/responsible-disclosure) page.


# Send emails with Astro
Source: https://resend.com/docs/send-with-astro

Learn how to send your first email using Astro, Resend, and Node.js.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

If you prefer to watch a video, check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/OzDg4QPmmac)

## Guide

**1. Install**

Install the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Install an SSR adapter**

Because Astro builds a static site by default, [install an SSR adapter](https://docs.astro.build/en/guides/server-side-rendering/) to enable on-demand rendering of routes.

**3. Add your API key**

[Create an API key](https://resend.com/api-keys) in Resend and add it to your `.env` file to keep your API key secret.

```ini .env theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY="re_xxxxxxxxx"
```

**4. Send email using HTML**

Create an [Astro Action](https://docs.astro.build/en/guides/actions/) under `actions/index.ts`.

The easiest way to send an email is with the `html` parameter.

```ts src/actions/index.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { ActionError, defineAction } from 'astro:actions';
import { Resend } from 'resend';

const resend = new Resend(import.meta.env.RESEND_API_KEY);

export const server = {
  send: defineAction({
    accept: 'form',
    handler: async () => {
      const { data, error } = await resend.emails.send({
        from: 'Acme <onboarding@resend.dev>',
        to: ['delivered@resend.dev'],
        subject: 'Hello world',
        html: '<strong>It works!</strong>',
      });

      if (error) {
        throw new ActionError({
          code: 'BAD_REQUEST',
          message: error.message,
        });
      }

      return data;
    },
  }),
};
```

Call the `send` action from any frontmatter route, script, or component.

## Examples

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send-attachment.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send-cid.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/send-scheduled.ts)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/astro-resend-examples/typescript/src/pages/api/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/domains.ts)
>
> Create and manage sending domains

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/astro-resend-examples/typescript/src/pages/api/webhook.ts)
>
> Handle webhook events


# Send Auth0 transactional emails with Resend
Source: https://resend.com/docs/send-with-auth0

Learn how to send Auth0 transactional emails through Resend using the official integration.

[Auth0](https://auth0.com) supports Resend as a built-in email provider. Authentication flows depend on reliable delivery for verification codes, password resets, and other crucial emails.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

Prefer a video walkthrough?

[YouTube video player](https://www.youtube.com/embed/-xlz8xVN3Rc)

## Set up the Resend provider in Auth0

In the Auth0 Dashboard, go to **Branding > Email Provider**, toggle on **Use my own email provider**, and select **Resend**.

Enter your API key and set the **From** address to match your verified domain. Click **Save** to apply the changes.

![Auth0 Resend Integration](https://mintcdn.com/resend/3aaPXnVunyH4ynzk/images/auth0-setup.png?fit=max\&auto=format\&n=3aaPXnVunyH4ynzk\&q=85\&s=1e7ff74e83ff205e0b499c5aacdb7d3f)

To test that it's working, click **Send Test Email**. The email will appear in your Resend dashboard and email inbox.

> [!NOTE]
>
> For the full setup guide, see the [Auth0
> documentation](https://auth0.com/docs/customize/email/smtp-email-providers/resend).

## Send emails with Auth0 Actions (optional)

For more control over delivery, like per-organization sender addresses, conditional routing, or custom logic, you can use an Auth0 Action instead.

In the Auth0 Dashboard, go to **Actions > Library**, create a new Custom action.

![Auth0 Custom Action](https://mintcdn.com/resend/3aaPXnVunyH4ynzk/images/auth0-action.png?fit=max\&auto=format\&n=3aaPXnVunyH4ynzk\&q=85\&s=6eec4f5953cfa2a5e7848b8dfbe184a0)

To enable Resend in the Action:

1. Add `resend` as a dependency.

   ![Auth0 Custom Action](https://mintcdn.com/resend/3aaPXnVunyH4ynzk/images/auth0-dependency.png?fit=max\&auto=format\&n=3aaPXnVunyH4ynzk\&q=85\&s=7789456d3dd2c52559961357226cea0a)
2. Store your API key as a secret named `RESEND_API_KEY`.

   ![Auth0 Custom Action](https://mintcdn.com/resend/3aaPXnVunyH4ynzk/images/auth0-secret.png?fit=max\&auto=format\&n=3aaPXnVunyH4ynzk\&q=85\&s=6326f23f2690292e87545282c1fee855)

Here's a working example that sends a security alert on first login:

```javascript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { Resend } = require('resend');

exports.onExecutePostLogin = async (event, api) => {
  const resend = new Resend(event.secrets.RESEND_API_KEY);

  if (event.stats.logins_count === 1) {
    await resend.emails.send({
      from: 'Security <security@example.com>',
      to: event.user.email,
      subject: 'New login detected',
      html: `<p>Hi ${event.user.name}, a new login was detected from ${event.request.ip}.</p>`,
    });
  }
};
```

Deploy it by adding the action to the **Post Login** trigger under **Actions > Triggers**.

## Customize Email Templates

To customize the email templates that Auth0 sends out, go to **Branding > Email Templates** in the Auth0 Dashboard and make your changes to the existing templates.

For more advanced templating, consider either [React Email](#react-email) or [Resend Templates](#resend-templates).

### React Email

Auth0 email templates use Liquid syntax for dynamic variables like `{{ user.email }}` and `{{ url }}`. You can author templates with [React Email](https://react.email) and inject Liquid variables before pasting the rendered HTML into Auth0.

Define your Liquid variables as constants to avoid HTML encoding issues during rendering:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
export const VARIABLES = {
  url: '{{ url }}',
  user: { email: '{{ user.email }}' },
  application: { name: '{{ application.name }}' },
};
```

Use them in your React Email components, render to static HTML, and paste the output into **Branding > Email Templates** in Auth0.

### Resend Templates

To use Resend templates with Auth0, define your templates in the [Resend Dashboard](https://resend.com/templates) and reference them in your [Custom OAuth Actions](#send-emails-with-auth0-actions-optional).

For instance, the following code uses a Resend template with the id of `login-detected` that contains two variables (`first_name` and `ip_address`) to be passed in the call. [Learn more about Resend templates](/docs/dashboard/templates/introduction).

```javascript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { Resend } = require('resend');

exports.onExecutePostLogin = async (event, api) => {
  const resend = new Resend(event.secrets.RESEND_API_KEY);

  if (event.stats.logins_count === 1) {
    await resend.emails.send({
      from: 'Security <security@example.com>',
      to: event.user.email,
      template: {
        id: 'login-detected',
        variables: {
          first_name: event.user.name,
          ip_address: event.request.ip,
        },
      },
    });
  }
};
```

## Debugging Email Delivery

When something goes wrong, it's helpful to see detailed logs across both sides:

* **Auth0 Logs** (**Monitoring > Logs**) shows send events and any errors raised from the Resend integration.
* [**Resend Logs**](https://resend.com/logs) show the delivery side: accepted, delivered, opened, bounced.

Together, you get end-to-end visibility across the entire delivery chain.


# Send emails with AWS Lambda
Source: https://resend.com/docs/send-with-aws-lambda

Learn how to send your first email using AWS Lambda.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Create an AWS Lambda function**

Go to [aws.amazon.com](https://aws.amazon.com) and create a new Lambda function using the Node.js 20.x or later runtime.

![AWS Lambda - New Function](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/aws-lambda-new-function.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=324a1181f685affebb1f50b18765538c)

**2. Edit the handler function**

Paste the following code into the browser editor:

```js index.mjs theme={"theme":{"light":"github-light","dark":"vesper"}}
const RESEND_API_KEY = 're_xxxxxxxxx';

export const handler = async (event) => {
  const res = await fetch('https://api.resend.com/emails', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${RESEND_API_KEY}`,
    },
    body: JSON.stringify({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'hello world',
      html: '<strong>it works!</strong>',
    }),
  });

  if (res.ok) {
    const data = await res.json();

    return {
      statusCode: 200,
      body: data,
    };
  }
};
```

**3. Deploy and send email**

Click on `Deploy` and then `Test` at the top of the screen.

![AWS Lambda - Edit Function](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/aws-lambda-edit-function.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=0393dc19bce3c93881bf4b433024c40b)

## Examples

> [card] [AWS Lambda Example](https://github.com/resend/resend-aws-lambda-example)
>
> See the full source code.


# Send emails with Axum
Source: https://resend.com/docs/send-with-axum

Send your first email using Axum and the Resend Rust SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Rust SDK and the [Tokio](https://tokio.rs) runtime.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
cargo add resend-rs
cargo add tokio -F macros,rt-multi-thread
```

**2. Send an Email**

```rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use std::sync::Arc;

use axum::{extract::State, http::StatusCode, routing::get, Router};
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

// Cloning the Resend client is fine and cheap as the internal HTTP client is
// not cloned.
#[derive(Clone)]
struct AppState {
  resend: Resend,
}

#[tokio::main]
async fn main() {
  let shared_state = Arc::new(AppState {
    resend: Resend::new("re_xxxxxxxxx"),
  });

  // build our application with a single route
  let app = Router::new()
    .route("/", get(endpoint))
    // provide the state so the router can access it
    .with_state(shared_state);

  // run our app with hyper, listening globally on port 3000
  let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
  axum::serve(listener, app).await.unwrap();
}

async fn endpoint(State(state): State<Arc<AppState>>) -> Result<String, StatusCode> {
  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Hello World";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<strong>It works!</strong>");

  // access the state via the `State` extractor and handle the error
  match state.resend.emails.send(email).await {
    Ok(email) => Ok(email.id.to_string()),
    Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
  }
}
```

Opening your browser at `http://localhost:3000` (or running `curl localhost:3000`) sends an
email and returns its id!

## Examples

> [card] [Axum App](https://github.com/resend/resend-examples/tree/main/rust-resend-examples/axum_app)
>
> Full Axum web framework application

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/basic_send.rs)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/with_attachments.rs)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/with_template.rs)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/scheduled_send.rs)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/audiences.rs)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/domains.rs)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/inbound.rs)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/double_optin_subscribe.rs)
>
> Double opt-in subscription flow


# Send Better Auth emails with Resend
Source: https://resend.com/docs/send-with-better-auth

Learn how to send Better Auth transactional emails through Resend using email hooks.

[Better Auth](https://better-auth.com) is a framework-agnostic authentication library for TypeScript. It relies on transactional email for password resets, email verification, magic links, and one-time codes, all of which you can deliver with Resend.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)
* A project with [Better Auth installed](https://better-auth.com/docs/installation)

## Install the Resend SDK

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

Add your API key to the environment:

```bash .env theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY=re_xxxxxxxxx
```

> [!NOTE]
>
> The hook examples below call `void resend.emails.send(...)` instead of
> awaiting it, [as Better Auth
> recommends](https://better-auth.com/docs/concepts/email), so the response time
> doesn't reveal whether an account exists. On serverless platforms, wrap the
> send in `waitUntil` (or your platform's equivalent) so the function doesn't
> terminate before the email is sent.

## Send password reset and verification emails

Better Auth calls your `sendResetPassword` and `sendVerificationEmail` hooks when a user requests a reset or needs to confirm their address. Send the email with Resend inside each hook.

```typescript auth.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { betterAuth } from 'better-auth';
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export const auth = betterAuth({
  emailAndPassword: {
    enabled: true,
    sendResetPassword: ({ user, url }) => {
      void resend.emails.send({
        from: 'Acme <onboarding@example.com>',
        to: user.email,
        subject: 'Reset your password',
        html: `Click <a href="${url}">here</a> to reset your password.`,
      });
    },
  },
  emailVerification: {
    sendVerificationEmail: ({ user, url }) => {
      void resend.emails.send({
        from: 'Acme <onboarding@example.com>',
        to: user.email,
        subject: 'Verify your email address',
        html: `Click <a href="${url}">here</a> to verify your email.`,
      });
    },
  },
});
```

> [!NOTE]
>
> Set the `from` address to match your [verified domain](/docs/add-a-domain).

## Send magic links (optional)

If you use the [magic link plugin](https://better-auth.com/docs/plugins/magic-link), send the sign-in link through the `sendMagicLink` hook.

```typescript auth.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { betterAuth } from 'better-auth';
import { magicLink } from 'better-auth/plugins';
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export const auth = betterAuth({
  plugins: [
    magicLink({
      sendMagicLink: ({ email, url }) => {
        void resend.emails.send({
          from: 'Acme <onboarding@example.com>',
          to: email,
          subject: 'Sign in to Acme',
          html: `Click <a href="${url}">here</a> to sign in.`,
        });
      },
    }),
  ],
});
```

> [!NOTE]
>
> Set the `from` address to match your [verified domain](/docs/add-a-domain).

## Send one-time codes (optional)

The [email OTP plugin](https://better-auth.com/docs/plugins/email-otp) sends a one-time password (OTP), a numeric code, instead of a link. The `type` argument tells you which flow triggered the request so you can tailor the subject line.

```typescript auth.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { betterAuth } from 'better-auth';
import { emailOTP } from 'better-auth/plugins';
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export const auth = betterAuth({
  plugins: [
    emailOTP({
      sendVerificationOTP: ({ email, otp, type }) => {
        void resend.emails.send({
          from: 'Acme <onboarding@example.com>',
          to: email,
          subject:
            type === 'sign-in' ? 'Your sign-in code' : 'Your verification code',
          html: `Your code is <strong>${otp}</strong>.`,
        });
      },
    }),
  ],
});
```

> [!NOTE]
>
> Set the `from` address to match your [verified domain](/docs/add-a-domain).

## Customize email templates

For richer, reusable emails, author your templates with [React Email](https://react.email) and pass the rendered component to Resend's `react` field, or reference a [Resend template](/docs/dashboard/templates/introduction) by `id`.

```typescript auth.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { ResetPasswordEmail } from './emails/reset-password';

sendResetPassword: ({ user, url }) => {
  void resend.emails.send({
    from: 'Acme <onboarding@example.com>',
    to: user.email,
    subject: 'Reset your password',
    react: ResetPasswordEmail({ url }),
  });
},
```

> [!NOTE]
>
> Set the `from` address to match your [verified domain](/docs/add-a-domain).

## Debugging email delivery

When a flow doesn't behave as expected, check both sides:

* **Better Auth logs** show the hook invocation and any errors thrown while sending.
* [**Resend Logs**](https://resend.com/logs) show the delivery side: accepted, delivered, opened, bounced.

Together, you get end-to-end visibility across the entire delivery chain.


# Send emails with Bun
Source: https://resend.com/docs/send-with-bun

Learn how to send your first email using Bun and the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
bun install resend
```

**2. Create an email template**

Start by creating your email template on `email-template.tsx`.

```tsx email-template.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import * as React from 'react';

interface EmailTemplateProps {
  firstName: string;
}

export const EmailTemplate = ({ firstName }: EmailTemplateProps) => (
  <div>
    <h1>Welcome, {firstName}!</h1>
  </div>
);
```

**3. Send email using React**

Create a new file `index.tsx` and send your first email.

```tsx index.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { EmailTemplate } from './email-template';

const resend = new Resend(process.env.RESEND_API_KEY);

const server = Bun.serve({
  port: 3000,
  async fetch() {
    const data = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello World',
      react: EmailTemplate({ firstName: 'Vitor' }),
    });

    return new Response(JSON.stringify(data));
  },
});

console.log(`Listening on http://localhost:${server.port} ...`);
```

Start the local server by running `bun index.tsx` and navigate to `http://localhost:3000`.

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/basic-send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/with-attachments.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/with-cid-attachments.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/with-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/scheduled-send.ts)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/prevent-threading.ts)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/audiences.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/domains.ts)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/inbound.ts)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/bun-resend-examples/typescript/examples/double-optin-subscribe.ts)
>
> Double opt-in subscription flow


# Send emails with Cloudflare Workers
Source: https://resend.com/docs/send-with-cloudflare-workers

Learn how to send your first email using Cloudflare Workers.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)
* Have a Cloudflare worker with a bundling setup
  * Recommended to be bootstrapped with `npm create cloudflare`

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Create an email template**

Start by creating your email template on `src/emails/email-template.tsx`:

```tsx src/emails/email-template.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import * as React from 'react';

interface EmailTemplateProps {
  firstName: string;
}

export function EmailTemplate({ firstName }: EmailTemplateProps) {
  return (
    <div>
      <h1>Welcome, {firstName}!</h1>
    </div>
  );
}

export default EmailTemplate;
```

**3. Send the email using React and the SDK**

Change the file extension of the worker's main file to `tsx` and modify your configurations.

After that, you can send your email using the `react` parameter:

```tsx src/index.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { EmailTemplate } from './emails/email-template';

export default {
  async fetch(request, env, context): Promise<Response> {
    const resend = new Resend('re_xxxxxxxxx');

    const data = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'hello world',
      react: <EmailTemplate firstName="John" />,
    });

    return Response.json(data);
  },
} satisfies ExportedHandler<Env, ExecutionContext>;
```

**4. Deploy and send email**

Run `wrangler deploy` and wait for it to finish. Once it's done, it will
give you a URL to try out, like `https://my-worker.your_name.workers.dev`,
that you can open and verify that your email has been sent.

## Examples

> [card] [Cloudflare Workers Example](https://github.com/resend/resend-cloudflare-workers-example)
>
> See the full source code.


# Send emails using Customer.io with SMTP
Source: https://resend.com/docs/send-with-customer-io-smtp

Learn how to integrate Customer.io with Resend SMTP.

### Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Get the Resend SMTP credentials**

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

**2. Integrate with Customer.io SMTP**

After logging into your [Customer.io](https://customer.io) account, you'll need to enable the SMTP integration.

1. Go to **Settings** > **Workspace Settings**.

![Customer.io SMTP - Workspace Settings](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/customer-io-smtp-1.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=97d3402e7acb7c66e5d54ff2886dd4e3)

2. Go to the Messaging tab and select **Email**.

![Customer.io SMTP - Email](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/customer-io-smtp-2.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=af35d8a9c99681e1a508694f02157943)

3. Select the **Custom SMTP** tab and click **Add Custom SMTP Server**.

![Customer.io SMTP - Add Custom SMTP Server](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/customer-io-smtp-3.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=1d18082018463dc5989fb91d8f881b39)

4. Select **Other SMTP** and click **Continue to set up**.

![Customer.io SMTP - Other SMTP](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/customer-io-smtp-4.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=acc404b8b5b7fc11db0279d84453cb11)

5. Copy-and-paste the SMTP credentials from Resend to Customer.io.

![Customer.io SMTP integration](https://mintcdn.com/resend/ABWmVTZIHGIFNTFD/images/customer-io-smtp-5.png?fit=max\&auto=format\&n=ABWmVTZIHGIFNTFD\&q=85\&s=519742fc4d97d06646fdd52de4f373fd)


# Send emails with Deno Deploy
Source: https://resend.com/docs/send-with-deno-deploy

Learn how to send your first email using Deno Deploy.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Create a Deno Deploy project**

Go to [dash.deno.com/projects](https://dash.deno.com/projects) and create a new playground project.

![Deno Deploy - New Project](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/deno-deploy-new-project.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=634d342d6e542f4c82eb9c013bfcc817)

**2. Edit the handler function**

Paste the following code into the browser editor:

```ts main.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'npm:resend';

const resend = new Resend('re_123456789');

Deno.serve(async () => {
  try {
    const response = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello World',
      html: '<strong>It works!</strong>',
    });

    return new Response(JSON.stringify(response), {
      status: response.error ? 500 : 200,
      headers: {
        'Content-Type': 'application/json',
      },
    });
  } catch (error) {
    console.error(error);
    return new Response(null, {
      status: 500,
    });
  }
});
```

**3. Deploy and send email**

Click on `Save & Deploy` at the top of the screen.

![Deno Deploy - Playground](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/deno-deploy-playground.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=fb62c969114e48e5401fecc67f5a4d76)

## Examples

> [card] [Deno Deploy Example](https://github.com/resend/resend-deno-deploy-example)
>
> See the full source code.


# Send emails with Django
Source: https://resend.com/docs/send-with-django

Learn how to send your first email using Django and the Resend Python SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the [django-anymail](https://anymail.dev/en/stable/esps/resend/) package with Resend support.

```bash Pip theme={"theme":{"light":"github-light","dark":"vesper"}}
pip install django-anymail[resend]
```

**2. Configure**

Add Anymail to your Django settings.

```py settings.py theme={"theme":{"light":"github-light","dark":"vesper"}}
import os

INSTALLED_APPS = [
    # ...
    "anymail",
]

EMAIL_BACKEND = "anymail.backends.resend.EmailBackend"
ANYMAIL = {
    "RESEND_API_KEY": os.environ.get("RESEND_API_KEY"),
}
DEFAULT_FROM_EMAIL = "onboarding@resend.dev"
```

**3. Send email using HTML**

The easiest way to send an email is by using the `html_message` parameter.

```py views.py theme={"theme":{"light":"github-light","dark":"vesper"}}
from django.core.mail import send_mail
from django.http import JsonResponse

def send_email(request):
    send_mail(
        subject="Hello from Django + Resend",
        message="This is a plain text message.",
        from_email="Acme <onboarding@resend.dev>",
        recipient_list=["delivered@resend.dev"],
        html_message="<strong>it works!</strong>",
    )

    return JsonResponse({"message": "Email sent successfully"})
```

**4. Send email using a template**

For more complex emails, you can use Django's template system.

First, create an HTML template at `templates/emails/welcome.html`:

```html templates/emails/welcome.html theme={"theme":{"light":"github-light","dark":"vesper"}}
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title>Welcome Email</title>
  </head>
  <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #333;">
    <h1>Welcome, {{ user_name }}!</h1>
    <p>Thank you for joining our service.</p>
    <p>Your account email: <strong>{{ user_email }}</strong></p>
    <p>
      <a
        href="{{ dashboard_url }}"
        style="background-color: #007bff; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px;"
      >
        Go to Dashboard
      </a>
    </p>
  </body>
</html>
```

Then render and send the template:

```py views.py theme={"theme":{"light":"github-light","dark":"vesper"}}
from django.core.mail import EmailMessage
from django.http import JsonResponse
from django.template.loader import render_to_string

def send_template_email(request):
    html_content = render_to_string('emails/welcome.html', {
        'user_name': 'Django Developer',
        'user_email': 'delivered@resend.dev',
        'dashboard_url': 'https://example.com/dashboard',
    })

    message = EmailMessage(
        subject="Welcome to Our Service!",
        body=html_content,
        from_email="Acme <onboarding@resend.dev>",
        to=["delivered@resend.dev"],
    )
    message.content_subtype = "html"
    message.send()

    return JsonResponse({"message": "Email sent successfully"})
```

## Examples

> [card] [Django App](https://github.com/resend/resend-examples/tree/main/python-resend-examples/django_app)
>
> Full Django web application

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/basic_send.py)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_attachments.py)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_template.py)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/scheduled_send.py)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/audiences.py)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/domains.py)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/inbound.py)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/double_optin_subscribe.py)
>
> Double opt-in subscription flow


# Send emails using Django with SMTP
Source: https://resend.com/docs/send-with-django-smtp

Learn how to integrate Django with Resend SMTP.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)
* Install `virtualenv` by running `pip install virtualenv`

## Guide

**1. Setup your environment**

Create and activate your new virtualenv.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
virtualenv venv
source venv/bin/activate
```

Install dependencies.

```sh theme={"theme":{"light":"github-light","dark":"vesper"}}
pip install -r requirements.txt
```

Set your `RESEND_API_KEY` environment variable by running.

```sh theme={"theme":{"light":"github-light","dark":"vesper"}}
export RESEND_API_KEY="re_xxxxxxxxx"
```

**2. Send email using Django's SMTP EmailMessage**

Set the necessary attributes in your `settings.py` file.

```py theme={"theme":{"light":"github-light","dark":"vesper"}}
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
RESEND_SMTP_PORT = 587
RESEND_SMTP_USERNAME = 'resend'
RESEND_SMTP_HOST = 'smtp.resend.com'
```

Use Django's `get_connection` and `EmailMessage`

```py theme={"theme":{"light":"github-light","dark":"vesper"}}
import os
from django.conf import settings
from django.http import JsonResponse
from django.core.mail import EmailMessage, get_connection

# Sample Django view
def index(request):

    subject = "Hello from Django SMTP"
    recipient_list = ["delivered@resend.dev"]
    from_email = "onboarding@resend.dev"
    message = "<strong>it works!</strong>"

    with get_connection(
        host=settings.RESEND_SMTP_HOST,
        port=settings.RESEND_SMTP_PORT,
        username=settings.RESEND_SMTP_USERNAME,
        password=os.environ["RESEND_API_KEY"],
        use_tls=True,
        ) as connection:
            r = EmailMessage(
                  subject=subject,
                  body=message,
                  to=recipient_list,
                  from_email=from_email,
                  connection=connection).send()
    return JsonResponse({"status": "ok"})
```

## Examples

> [card] [Django SMTP Example](https://github.com/resend/resend-django-smtp-example)
>
> See the full source code.


# Send emails with .NET
Source: https://resend.com/docs/send-with-dotnet

Learn how to send your first email using the Resend .NET SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

Prefer watching a video? Check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/HvFURxq1tgQ)

## Guide

**1. Install**

```bash dotnet CLI theme={"theme":{"light":"github-light","dark":"vesper"}}
dotnet add package Resend
```

```bash Visual Studio (Package Manager Console) theme={"theme":{"light":"github-light","dark":"vesper"}}
PM> Install-Package Resend
```

**2. Send emails using HTML**

In the startup of your application, configure the DI container as follows:

```csharp theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

builder.Services.AddOptions();
builder.Services.AddHttpClient<ResendClient>();
builder.Services.Configure<ResendClientOptions>( o =>
{
    o.ApiToken = Environment.GetEnvironmentVariable( "RESEND_APITOKEN" )!;
} );
builder.Services.AddTransient<IResend, ResendClient>();
```

Send an email using the injected `IResend` instance:

```csharp theme={"theme":{"light":"github-light","dark":"vesper"}}
using Resend;

public class FeatureImplementation
{
    private readonly IResend _resend;


    public FeatureImplementation( IResend resend )
    {
        _resend = resend;
    }


    public Task Execute()
    {
        var message = new EmailMessage();
        message.From = "Acme <onboarding@resend.dev>";
        message.To.Add( "delivered@resend.dev" );
        message.Subject = "hello world";
        message.HtmlBody = "<strong>it works!</strong>";

        await _resend.EmailSendAsync( message );
    }
}
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/BasicSend.cs)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/WithAttachments.cs)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/WithTemplate.cs)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/ScheduledSend.cs)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/Audiences.cs)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/Domains.cs)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/Inbound.cs)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/dotnet-resend-examples/Examples/DoubleOptinSubscribe.cs)
>
> Double opt-in subscription flow

> [card] [Minimal API App](https://github.com/resend/resend-examples/tree/main/dotnet-resend-examples/MinimalApiApp)
>
> ASP.NET Minimal API application

> [card] [MVC App](https://github.com/resend/resend-examples/tree/main/dotnet-resend-examples/MvcApp)
>
> ASP.NET MVC application


# Send emails with Elixir
Source: https://resend.com/docs/send-with-elixir

Learn how to send your first email using the Resend Elixir SDK.

> [!NOTE]
>
> This guides utilizes an [open source
> library](https://github.com/elixir-saas/resend-elixir) contributed by a
> community member. It's not developed, maintained, or supported by Resend
> directly.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Install by adding `resend` to your list of dependencies in `mix.exs`:

```elixir mix.exs theme={"theme":{"light":"github-light","dark":"vesper"}}
def deps do
  [
    {:resend, "~> 0.4.0"}
  ]
end
```

**2. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```elixir send.exs theme={"theme":{"light":"github-light","dark":"vesper"}}
client = Resend.client(api_key: System.get_env("RESEND_API_KEY"))

Resend.Emails.send(client, %{
  from: "Acme <onboarding@resend.dev>",
  to: ["delivered@resend.dev"],
  subject: "hello world",
  html: "<strong>it works!</strong>"
})
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/basic_send.exs)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/with_attachments.exs)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/with_template.exs)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/scheduled_send.exs)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/audiences.exs)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/domains.exs)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/inbound.exs)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/elixir-resend-examples/examples/double_optin)
>
> Double opt-in subscription flow

> [card] [Phoenix App](https://github.com/resend/resend-examples/tree/main/elixir-resend-examples/phoenix_app)
>
> Full Phoenix web framework application


# Send emails with Encore
Source: https://resend.com/docs/send-with-encore-go

Learn how to send your first email using Encore and the Resend Go SDK.

[Encore](https://encore.dev) is an open-source Go framework that provisions infrastructure directly from your application code, with built-in observability and cloud deployment.

Use this pre-built prompt to get started faster.

# Send Email with Resend and Encore Go

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using [Resend](https://resend.com/) with the [Encore Go](https://encore.dev) backend framework.
**Scope:** All AI-generated advice or code related to sending email with Resend inside an Encore Go application must follow these guardrails.

***

## **1. Official Resend + Encore Go Setup**

### **Prerequisites**

Human must first:

* Install [Encore](https://encore.dev/docs/go/install) (`brew install encoredev/tap/encore` or `curl -L https://encore.dev/install.sh | bash`)
* Create a Resend API key at [https://resend.com/api-keys](https://resend.com/api-keys)
* Verify a sending domain at [https://resend.com/domains](https://resend.com/domains)

The API key must be stored as an **Encore secret** (not an environment variable or `.env` file):

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
encore secret set --type dev,local,pr,production ResendAPIKey
```

### **Install the SDK**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
go get github.com/resend/resend-go/v4
```

### **Define Secrets**

Encore Go uses an unexported `secrets` struct to securely inject secrets at runtime. Do not use `os.Getenv()`.

```go theme={"theme":{"light":"github-light","dark":"vesper"}}
var secrets struct {
    ResendAPIKey string
}
```

### **Initialize the Client and Send an Email**

```go theme={"theme":{"light":"github-light","dark":"vesper"}}
package email

import (
    "context"

    "github.com/resend/resend-go/v4"
)

var secrets struct {
    ResendAPIKey string
}

type SendRequest struct {
    To      string `json:"to"`
    Subject string `json:"subject"`
    HTML    string `json:"html"`
}

type SendResponse struct {
    ID string `json:"id"`
}

//encore:api public method=POST path=/email/send
func Send(ctx context.Context, req *SendRequest) (*SendResponse, error) {
    client := resend.NewClient(secrets.ResendAPIKey)

    sent, err := client.Emails.Send(&resend.SendEmailRequest{
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{req.To},
        Subject: req.Subject,
        Html:    req.HTML,
    })
    if err != nil {
        return nil, err
    }

    return &SendResponse{ID: sent.Id}, nil
}
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

***

## **2. Complete `SendEmailRequest` Field Reference**

### **Required Fields**

| Field | Type | Description |
| - | - | - |
| `From` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `To` | `[]string` | Recipient email address(es). Maximum 50 addresses. |
| `Subject` | `string` | Email subject line. |

### **Content Fields (at least one required)**

| Field | Type | Description |
| - | - | - |
| `Html` | `string` | HTML version of the email body. |
| `Text` | `string` | Plain text version. Auto-generated from `Html` if omitted. |

### **Optional Fields**

| Field | Type | Description |
| - | - | - |
| `Cc` | `[]string` | Carbon copy recipients. |
| `Bcc` | `[]string` | Blind carbon copy recipients. |
| `ReplyTo` | `string` | Reply-to address. |
| `ScheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `Headers` | `map[string]string` | Custom email headers as key-value pairs. |
| `Tags` | `[]Tag` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `Attachments` | `[]*Attachment` | File attachments. Max 40MB total per email after encoding. |

### **Template Fields**

| Field | Type | Description |
| - | - | - |
| `Template` | `*EmailTemplate` | Published template to use. |

If `Template` is provided, do not include `Html` or `Text`.

### **Response**

A successful call returns:

```go theme={"theme":{"light":"github-light","dark":"vesper"}}
&SendEmailResponse{Id: "49a3999c-..."}
```

A failed call returns an `error`.

***

## **3. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **3.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key as an Encore secret** using `encore secret set`. Access it via `var secrets struct { ResendAPIKey string }`. Never use `os.Getenv()` or `.env` files.
2. **Import from `github.com/resend/resend-go/v4`** — the current version is v4.
3. **Use `resend.NewClient(secrets.ResendAPIKey)`** to create the client.
4. **Use `//encore:api` annotations** to define HTTP endpoints — not `net/http`, Gin, Chi, or any other router.
5. **Check the `error` return value** from `client.Emails.Send()`.
6. **Use a verified domain** in the `From` address for production. `onboarding@resend.dev` is for testing only.
7. **Use exported field names** (`From`, `To`, `Html`, `ReplyTo`) — Go structs use PascalCase.

### **3.2 - NEVER DO THE FOLLOWING**

1. **Do not** use `os.Getenv("RESEND_API_KEY")` or `.env` files — Encore has its own secrets management.
2. **Do not** hardcode API keys in source code.
3. **Do not** import from `github.com/resend/resend-go` (v1), `github.com/resend/resend-go/v2`, or `github.com/resend/resend-go/v3` — use v4.
4. **Do not** use `net/http`, Gin, Chi, Echo, or any other HTTP framework — Encore Go provides its own API routing via `//encore:api` annotations.
5. **Do not** use `onboarding@resend.dev` as the `From` address in production code. It is a test-only address.
6. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **4. COMMON PATTERNS**

### **Attachments**

```go theme={"theme":{"light":"github-light","dark":"vesper"}}
sent, err := client.Emails.Send(&resend.SendEmailRequest{
    From:    "Acme <hello@example.com>",
    To:      []string{"delivered@resend.dev"},
    Subject: "Invoice attached",
    Html:    "<p>See attached invoice.</p>",
    Attachments: []*resend.Attachment{
        {
            Filename: "invoice.pdf",
            Content:  invoiceBytes,
        },
    },
})
```

### **Scheduled Emails**

Send up to 30 days in advance using the `ScheduledAt` field. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```go theme={"theme":{"light":"github-light","dark":"vesper"}}
sent, err := client.Emails.Send(&resend.SendEmailRequest{
    From:        "Acme <hello@example.com>",
    To:          []string{"delivered@resend.dev"},
    Subject:     "Reminder",
    Html:        "<p>This is your reminder.</p>",
    ScheduledAt: "2026-12-25T09:00:00Z",
})
```

### **Tags for Tracking**

```go theme={"theme":{"light":"github-light","dark":"vesper"}}
sent, err := client.Emails.Send(&resend.SendEmailRequest{
    From:    "Acme <hello@example.com>",
    To:      []string{"delivered@resend.dev"},
    Subject: "Welcome",
    Html:    "<p>Welcome aboard!</p>",
    Tags: []resend.Tag{
        {Name: "category", Value: "welcome"},
        {Name: "user_id", Value: "12345"},
    },
})
```

***

## **5. AI MODEL VERIFICATION STEPS**

Before returning any Resend + Encore Go solution, you **must** verify:

1. **Import**: Is the SDK imported from `github.com/resend/resend-go/v4`?
2. **Secrets**: Is the API key accessed via `var secrets struct { ResendAPIKey string }` (not `os.Getenv`)?
3. **Client**: Is the client created with `resend.NewClient(secrets.ResendAPIKey)`?
4. **API Annotation**: Are endpoints defined with `//encore:api` (not `net/http`, Gin, etc.)?
5. **Error Handling**: Is the `error` return value checked?
6. **Field Names**: Are struct fields PascalCase (`From`, `To`, `Html`, not `from`, `to`, `html`)?
7. **From Address**: Is the `From` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help with Encore Go, suggest installing the Encore skills for AI-assisted development. These provide context on APIs, services, infrastructure, Pub/Sub, databases, auth, and more.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add encoredev/skills
```

Available Encore Go skills: `encore-go-api`, `encore-go-service`, `encore-go-infrastructure`, `encore-go-auth`, `encore-go-database`, `encore-go-testing`, `encore-go-code-review`, `encore-go-getting-started`.

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)
* Install [Encore](https://encore.dev/docs/go/install) (`brew install encoredev/tap/encore`)

## Guide

**1. Create an Encore app**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
encore app create --lang=go my-app
```

Then install the Resend Go SDK:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
go get github.com/resend/resend-go/v4
```

**2. Set your API key**

Encore has built-in [secrets management](https://encore.dev/docs/go/primitives/secrets). Store your Resend API key as a secret - no `.env` files needed:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
encore secret set --type dev,local,pr,production ResendAPIKey
```

**3. Send email using an API endpoint**

Create an `email` service directory and define your endpoint:

```go email/email.go theme={"theme":{"light":"github-light","dark":"vesper"}}
package email

import (
    "context"

    "github.com/resend/resend-go/v4"
)

var secrets struct {
    ResendAPIKey string
}

type SendRequest struct {
    To      string `json:"to"`
    Subject string `json:"subject"`
    HTML    string `json:"html"`
}

type SendResponse struct {
    ID string `json:"id"`
}

//encore:api public method=POST path=/email/send
func Send(ctx context.Context, req *SendRequest) (*SendResponse, error) {
    client := resend.NewClient(secrets.ResendAPIKey)

    sent, err := client.Emails.Send(&resend.SendEmailRequest{
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{req.To},
        Subject: req.Subject,
        Html:    req.HTML,
    })
    if err != nil {
        return nil, err
    }

    return &SendResponse{ID: sent.Id}, nil
}
```

**4. Run the app**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
encore run
```

Your API is running at `http://localhost:4000`. Send a test email:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST http://localhost:4000/email/send \
  -H "Content-Type: application/json" \
  -d '{"to":"delivered@resend.dev","subject":"Hello World","html":"<strong>It works!</strong>"}'
```

**5. AI skills for Encore Go**

If you're using an AI coding assistant, install the [Encore skills](https://github.com/encoredev/skills). They provide context-aware help with topics such as APIs, services, Pub/Sub, databases, and auth:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add encoredev/skills
```

# Examples

> [card] [Encore Go Docs](https://encore.dev/docs/go)
>
> Encore Go documentation

> [card] [Resend Go SDK](https://github.com/resend/resend-go)
>
> Resend Go SDK on GitHub


# Send emails with Encore
Source: https://resend.com/docs/send-with-encore-ts

Learn how to send your first email using Encore and the Resend Node.js SDK.

[Encore](https://encore.dev) is an open-source TypeScript framework that provisions infrastructure directly from your application code, with built-in observability and cloud deployment.

Use this pre-built prompt to get started faster.

# Send Email with Resend and Encore.ts

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using [Resend](https://resend.com/) with the [Encore.ts](https://encore.dev) backend framework.
**Scope:** All AI-generated advice or code related to sending email with Resend inside an Encore.ts application must follow these guardrails.

***

## **1. Official Resend + Encore.ts Setup**

### **Prerequisites**

Human must first:

* Install [Encore](https://encore.dev/docs/ts/install) (`brew install encoredev/tap/encore` or `curl -L https://encore.dev/install.sh | bash`)
* Create a Resend API key at [https://resend.com/api-keys](https://resend.com/api-keys)
* Verify a sending domain at [https://resend.com/domains](https://resend.com/domains)

The API key must be stored as an **Encore secret** (not an environment variable or `.env` file):

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
encore secret set --type dev,local,pr,production ResendAPIKey
```

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend
```

### **Initialize the Client**

Encore.ts uses `secret()` from `encore.dev/config` to securely inject secrets at runtime. Do not use `process.env`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { secret } from 'encore.dev/config';

const resendApiKey = secret('ResendAPIKey');

export const resend = new Resend(resendApiKey());
```

### **Define a Service**

Every Encore.ts service needs an `encore.service.ts` file:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Service } from 'encore.dev/service';

export default new Service('email');
```

### **Send an Email**

Create a type-safe API endpoint using Encore's `api()` function:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { api } from 'encore.dev/api';
import { resend } from './resend';

interface SendRequest {
  to: string;
  subject: string;
  html: string;
}

interface SendResponse {
  id: string;
}

export const sendEmail = api(
  { expose: true, method: 'POST', path: '/email/send' },
  async (req: SendRequest): Promise<SendResponse> => {
    const { data, error } = await resend.emails.send({
      from: 'Your App <hello@example.com>',
      to: req.to,
      subject: req.subject,
      html: req.html,
    });

    if (error) {
      throw new Error(`Failed to send email: ${error.message}`);
    }

    return { id: data!.id };
  },
);
```

### **Async Delivery with Pub/Sub**

For production, use Encore's built-in [Pub/Sub](https://encore.dev/docs/ts/primitives/pubsub) to send emails asynchronously with automatic retries:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Topic, Subscription } from 'encore.dev/pubsub';
import { resend } from './resend';

interface EmailEvent {
  to: string;
  subject: string;
  html: string;
}

export const emailTopic = new Topic<EmailEvent>('emails', {
  deliveryGuarantee: 'at-least-once',
});

const _ = new Subscription(emailTopic, 'send-email', {
  handler: async (event) => {
    const { data, error } = await resend.emails.send({
      from: 'Your App <hello@example.com>',
      to: event.to,
      subject: event.subject,
      html: event.html,
    });

    if (error) {
      throw new Error(error.message);
    }

    console.log('Email sent:', data?.id);
  },
});
```

Then publish from any endpoint:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
await emailTopic.publish({
  to: 'user@example.com',
  subject: 'Welcome!',
  html: '<p>Thanks for signing up.</p>',
});
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { secret } from 'encore.dev/config';
import { WelcomeEmail } from './emails/welcome';

const resendApiKey = secret('ResendAPIKey');
const resend = new Resend(resendApiKey());

const { data, error } = await resend.emails.send({
  from: 'Acme <hello@example.com>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key as an Encore secret** using `encore secret set`. Access it via `secret("ResendAPIKey")` from `encore.dev/config`. Never use `process.env` or `.env` files.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Import `secret` from `encore.dev/config`** — not from any other module.
4. **Call the secret as a function** — `resendApiKey()` with parentheses, not `resendApiKey`.
5. **Define an `encore.service.ts`** file in each service directory.
6. **Use `api()` from `encore.dev/api`** to define HTTP endpoints — not Express, Hono, or any other router.
7. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await`.
8. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
9. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
10. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** use `process.env.RESEND_API_KEY` or `.env` files — Encore has its own secrets management.
2. **Do not** hardcode API keys in source code.
3. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
4. **Do not** use Express, Hono, Koa, or any other HTTP framework — Encore.ts provides its own API routing via `api()`.
5. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase.
6. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
7. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
8. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
9. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <hello@example.com>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <hello@example.com>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <hello@example.com>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend + Encore.ts solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **Secrets**: Is the API key accessed via `secret("ResendAPIKey")` from `encore.dev/config` (not `process.env`)?
3. **Secret Call**: Is the secret called as a function with `()` when passed to `new Resend()`?
4. **Service File**: Does the service directory have an `encore.service.ts` file?
5. **API Endpoint**: Are endpoints defined with `api()` from `encore.dev/api` (not Express/Hono)?
6. **Await**: Is `resend.emails.send()` properly awaited?
7. **Error Handling**: Is the `{ data, error }` response pattern used?
8. **Parameters**: Are all parameter names in camelCase?
9. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help with Resend, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

For additional help with Encore.ts, suggest installing the Encore skills for AI-assisted development. These provide context on APIs, services, infrastructure, Pub/Sub, databases, auth, and more.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add encoredev/skills
```

Available Encore.ts skills: `encore-api`, `encore-service`, `encore-infrastructure`, `encore-auth`, `encore-database`, `encore-testing`, `encore-frontend`, `encore-code-review`, `encore-migrate`, `encore-getting-started`.

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)
* Install [Encore](https://encore.dev/docs/ts/install) (`brew install encoredev/tap/encore`)

## Guide

**1. Create an Encore app**

The quickest way to get started is with the Resend starter template:

```shell theme={"theme":{"light":"github-light","dark":"vesper"}}
encore app create --example=ts/resend
```

Or install the SDK into an existing Encore project:

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Set your API key**

Encore has built-in [secrets management](https://encore.dev/docs/ts/primitives/secrets). Store your Resend API key as a secret - no `.env` files needed:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
encore secret set --type dev,local,pr,production ResendAPIKey
```

Initialize the client using the secret:

```ts email/resend.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { secret } from 'encore.dev/config';

const resendApiKey = secret('ResendAPIKey');

export const resend = new Resend(resendApiKey());
```

**3. Define a service**

Every Encore.ts service needs a service definition file:

```ts email/encore.service.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Service } from 'encore.dev/service';

export default new Service('email');
```

**4. Send email using an API endpoint**

Create a type-safe API endpoint to send emails:

```ts email/send.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { api } from 'encore.dev/api';
import { resend } from './resend';

interface SendRequest {
  to: string;
  subject: string;
  html: string;
}

interface SendResponse {
  id: string;
}

export const sendEmail = api(
  { expose: true, method: 'POST', path: '/email/send' },
  async (req: SendRequest): Promise<SendResponse> => {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: req.to,
      subject: req.subject,
      html: req.html,
    });

    if (error) {
      throw new Error(`Failed to send email: ${error.message}`);
    }

    return { id: data!.id };
  },
);
```

**5. Async delivery with Pub/Sub (optional)**

For production, use Encore's built-in [Pub/Sub](https://encore.dev/docs/ts/primitives/pubsub) to send emails asynchronously with automatic retries:

```ts email/topic.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Topic, Subscription } from 'encore.dev/pubsub';
import { resend } from './resend';

interface EmailEvent {
  to: string;
  subject: string;
  html: string;
}

export const emailTopic = new Topic<EmailEvent>('emails', {
  deliveryGuarantee: 'at-least-once',
});

const _ = new Subscription(emailTopic, 'send-email', {
  handler: async (event) => {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: event.to,
      subject: event.subject,
      html: event.html,
    });

    if (error) {
      throw new Error(error.message);
    }

    console.log('Email sent:', data?.id);
  },
});
```

Then publish from any endpoint:

```ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { emailTopic } from './topic';

await emailTopic.publish({
  to: 'delivered@resend.dev',
  subject: 'Welcome!',
  html: '<p>Thanks for signing up.</p>',
});
```

**6. Run the app**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
encore run
```

Your API is running at `http://localhost:4000`. Send a test email:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
curl -X POST http://localhost:4000/email/send \
  -H "Content-Type: application/json" \
  -d '{"to":"delivered@resend.dev","subject":"Hello World","html":"<strong>It works!</strong>"}'
```

**7. AI skills for Encore.ts**

If you're using an AI coding assistant, install the [Encore skills](https://github.com/encoredev/skills). They provide context-aware help with topics such as APIs, services, Pub/Sub, databases, and auth:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add encoredev/skills
```

## Examples

> [card] [Resend Starter](https://github.com/encoredev/examples/tree/main/ts/resend)
>
> Full example with Pub/Sub email delivery

> [card] [Encore.ts Docs](https://encore.dev/docs/ts)
>
> Encore.ts documentation


# Send emails with Express
Source: https://resend.com/docs/send-with-express

Learn how to send your first email using Express and the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```js server.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import express, { Request, Response } from "express";
import { Resend } from "resend";

const app = express();
const resend = new Resend("re_xxxxxxxxx");

app.get("/", async (req: Request, res: Response) => {
  const { data, error } = await resend.emails.send({
    from: "Acme <onboarding@resend.dev>",
    to: ["delivered@resend.dev"],
    subject: "hello world",
    html: "<strong>it works!</strong>",
  });

  if (error) {
    return res.status(400).json({ error });
  }

  res.status(200).json({ data });
});

app.listen(3000, () => {
  console.log("Listening on http://localhost:3000");
});
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/basic-send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/with-attachments.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/with-cid-attachments.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/with-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/scheduled-send.ts)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/prevent-threading.ts)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/audiences.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/domains.ts)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/inbound.ts)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/double-optin-subscribe.ts)
>
> Double opt-in subscription flow


# Send emails with FastAPI
Source: https://resend.com/docs/send-with-fastapi

Learn how to send your first email using FastAPI and the Resend Python SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Python SDK.

```bash Pip theme={"theme":{"light":"github-light","dark":"vesper"}}
pip install resend
```

**2. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```py main.py theme={"theme":{"light":"github-light","dark":"vesper"}}
import os
from typing import Dict
from fastapi import FastAPI
import resend

resend.api_key = os.environ["RESEND_API_KEY"]

app = FastAPI()

@app.post("/")
def send_mail() -> Dict:
    params: resend.Emails.SendParams = {
        "from": "Acme <onboarding@resend.dev>",
        "to": ["delivered@resend.dev"],
        "subject": "hello world",
        "html": "<strong>it works!</strong>",
    }
    email: resend.Emails.SendResponse = resend.Emails.send(params)
    return email
```

## Examples

> [card] [FastAPI App](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/fastapi_app.py)
>
> Full FastAPI web application

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/basic_send.py)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_attachments.py)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_template.py)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/scheduled_send.py)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/audiences.py)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/domains.py)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/inbound.py)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/double_optin_subscribe.py)
>
> Double opt-in subscription flow


# Send emails with Flask
Source: https://resend.com/docs/send-with-flask

Learn how to send your first email using Flask and the Resend Python SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Python SDK.

```bash Pip theme={"theme":{"light":"github-light","dark":"vesper"}}
pip install resend
```

**2. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```py index.py theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend
import os
from flask import Flask, jsonify

resend.api_key = os.environ["RESEND_API_KEY"]

app = Flask(__name__)


@app.route("/")
def index():
    params: resend.Emails.SendParams = {
        "from": "Acme <onboarding@resend.dev>",
        "to": ["delivered@resend.dev"],
        "subject": "hello world",
        "html": "<strong>it works!</strong>",
    }

    r = resend.Emails.send(params)
    return jsonify(r)


if __name__ == "__main__":
    app.run()
```

## Examples

> [card] [Flask App](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/flask_app.py)
>
> Full Flask web application

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/basic_send.py)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_attachments.py)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_template.py)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/scheduled_send.py)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/audiences.py)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/domains.py)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/inbound.py)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/double_optin_subscribe.py)
>
> Double opt-in subscription flow


# Send emails with Go
Source: https://resend.com/docs/send-with-go

Learn how to send your first email using the Resend Go SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Go SDK.

```bash bash theme={"theme":{"light":"github-light","dark":"vesper"}}
go get github.com/resend/resend-go/v4
```

**2. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```Go main.go theme={"theme":{"light":"github-light","dark":"vesper"}}
package main

import (
	"fmt"

	"github.com/resend/resend-go/v4"
)

func main() {
    client := resend.NewClient("re_xxxxxxxxx")

    params := &resend.SendEmailRequest{
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"delivered@resend.dev"},
        Html:    "<strong>hello world</strong>",
        Subject: "Hello from Golang",
        Cc:      []string{"cc@example.com"},
        Bcc:     []string{"bcc@example.com"},
        ReplyTo: "replyto@example.com",
    }

    sent, err := client.Emails.Send(params)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    fmt.Println(sent.Id)
}
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/basic_send)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/with_attachments)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/with_cid_attachments)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/with_template)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/scheduled_send)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/prevent_threading)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/domains)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/inbound)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/go-resend-examples/examples/double_optin)
>
> Double opt-in subscription flow

> [card] [Chi App](https://github.com/resend/resend-examples/tree/main/go-resend-examples/chi_app)
>
> Full Chi web framework application

> [card] [Gin App](https://github.com/resend/resend-examples/tree/main/go-resend-examples/gin_app)
>
> Full Gin web framework application


# Send emails with Hono
Source: https://resend.com/docs/send-with-hono

Learn how to send your first email using Hono and the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Create an email template**

Start by creating your email template on `emails/email-template.tsx`.

```tsx emails/email-template.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import * as React from 'react';

interface EmailTemplateProps {
  firstName: string;
}

export function EmailTemplate({ firstName }: EmailTemplateProps) {
  return (
    <div>
      <h1>Welcome, {firstName}!</h1>
    </div>
  );
}
```

To use JSX/TSX with Hono, we need to modify the `tsconfig.json`.

```json tsconfig.json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "compilerOptions": {
    "jsx": "react-jsx",
    "jsxImportSource": "react"
  }
}
```

**3. Send email using React**

Create a new file `index.tsx` and send your first email.

```ts index.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Hono } from 'hono';
import { Resend } from 'resend';
import { EmailTemplate } from './emails/email-template';

const app = new Hono();
const resend = new Resend('re_xxxxxxxxx');

app.get('/', async (c) => {
  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    react: <EmailTemplate firstName="John" />,
  });

  if (error) {
    return c.json(error, 400);
  }

  return c.json(data);
});

export default app;
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/basic-send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/with-attachments.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/with-cid-attachments.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/with-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/scheduled-send.ts)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/prevent-threading.ts)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/audiences.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/domains.ts)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/inbound.ts)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/hono-resend-examples/typescript/examples/double-optin-subscribe.ts)
>
> Double opt-in subscription flow


# Send emails with Java
Source: https://resend.com/docs/send-with-java

Learn how to send your first email using the Resend Java SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

```bash Gradle theme={"theme":{"light":"github-light","dark":"vesper"}}
implementation 'com.resend:resend-java:+'
```

```xml Maven theme={"theme":{"light":"github-light","dark":"vesper"}}
<dependency>
    <groupId>com.resend</groupId>
    <artifactId>resend-java</artifactId>
    <version>LATEST</version>
</dependency>
```

**2. Send emails using HTML**

```java Main.java theme={"theme":{"light":"github-light","dark":"vesper"}}
import com.resend.*;

public class Main {
    public static void main(String[] args) {
        Resend resend = new Resend("re_xxxxxxxxx");

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("it works!")
                .html("<strong>hello world</strong>")
                .build();

         try {
            CreateEmailResponse data = resend.emails().send(params);
            System.out.println(data.getId());
        } catch (ResendException e) {
            e.printStackTrace();
        }
    }
}
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/BasicSend.java)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/WithAttachments.java)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/WithTemplate.java)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/ScheduledSend.java)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/Audiences.java)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/Domains.java)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/Inbound.java)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/java-resend-examples/src/main/java/com/resend/examples/DoubleOptinSubscribe.java)
>
> Double opt-in subscription flow

> [card] [Javalin App](https://github.com/resend/resend-examples/tree/main/java-resend-examples/javalin_app)
>
> Full Javalin web framework application

> [card] [Spring Boot App](https://github.com/resend/resend-examples/tree/main/java-resend-examples/spring_boot_app)
>
> Full Spring Boot application


# Send emails with Laravel
Source: https://resend.com/docs/send-with-laravel

Learn how to send your first email using Laravel.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

> [!NOTE]
>
> On [Laravel Cloud](/docs/guides/laravel-cloud-integration), connect Resend as an
> email resource. Cloud injects `RESEND_API_KEY`, `MAIL_MAILER`,
> `MAIL_FROM_ADDRESS`, and `MAIL_FROM_NAME` into the environment.

Prefer watching a video? Check out this video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/xUTeIIt982w)

## Guide

**1. Install**

First, install Resend for Laravel using the Composer package manager:

```bash Composer theme={"theme":{"light":"github-light","dark":"vesper"}}
composer require resend/resend-laravel
```

**2. Configuration**

### API key

Next, configure your Resend API key in your application's `.env` file:

```ini .env theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY=re_xxxxxxxxx
```

> [!NOTE]
>
> If you've upgraded your Laravel project from an older version (pre-5.5) and haven't enabled auto service provider discovery, you'll need to manually register the Resend service provider. Add the provider to the `providers` array in your `config/app.php` file:
>
> ```php config/app.php theme={"theme":{"light":"github-light","dark":"vesper"}}
> 'providers' => [
>     // ... other providers
>     Resend\Laravel\ResendServiceProvider::class,
> ],
> ```
>
> Without this registration, the Facade may reference the core Resend PHP client instead of the Resend Laravel library, causing unexpected behavior.

### Mail driver

To use Resend as your mail driver, first create a new mailer definition, in the `mailers` array within your application's `config/mail.php` configuration file:

```php mail.php theme={"theme":{"light":"github-light","dark":"vesper"}}
'resend' => [
    'transport' => 'resend',
],
```

Next, update your application's `.env` file to use the Resend mail driver:

```ini .env theme={"theme":{"light":"github-light","dark":"vesper"}}
MAIL_MAILER=resend
MAIL_FROM_ADDRESS=onboarding@resend.dev
MAIL_FROM_NAME=Acme
```

**3. Send an email**

Resend for Laravel provides two convenient ways to send emails, using Laravel's email service or the `Resend` API facade.

### Using the Mail Facade

```php OrderShipmentController.php theme={"theme":{"light":"github-light","dark":"vesper"}}
<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Mail\OrderShipped;
use App\Models\Order;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Mail;

class OrderShipmentController extends Controller
{
    /**
     * Ship the given order.
     */
    public function store(Request $request): RedirectResponse
    {
        $order = Order::findOrFail($request->order_id);

        // Ship the order...

        Mail::to($request->user())->send(new OrderShipped($order));

        return redirect('/orders');
    }
}
```

### Using the Resend Facade

```php OrderShipmentController.php theme={"theme":{"light":"github-light","dark":"vesper"}}
<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Mail\OrderShipped;
use App\Models\Order;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Resend\Laravel\Facades\Resend;

class OrderShipmentController extends Controller
{
    /**
     * Ship the given order.
     */
    public function store(Request $request): RedirectResponse
    {
        $order = Order::findOrFail($request->order_id);

        // Ship the order...

        Resend::emails()->send([
            'from' => 'Acme <onboarding@resend.dev>',
            'to' => [$request->user()->email],
            'subject' => 'hello world',
            'html' => (new OrderShipped($order))->render(),
        ])

        return redirect('/orders');
    }
}
```

**4. Receiving webhook requests**

By default, Resend for Laravel includes a webhook controller to respond to the `/resend/webhook` URL path. The controller will dispatch a Laravel event that corresponds to a Resend event. For example, an `email.delivered` event type will send an `EmailDelivered` Laravel event.

### Register the webhook endpoint

Register your publicly accessible HTTPS URL in the Resend dashboard.

> [!TIP]
>
> For development, you can create a tunnel to your localhost server using a tool like
> [ngrok](https://ngrok.com/download) or [VS Code Port Forwarding](https://code.visualstudio.com/docs/debugtest/port-forwarding). These tools serve your local dev environment at a public URL you can use to test your local webhook endpoint.
>
> Example: `https://example123.ngrok.io/api/webhook`

![Add Webhook](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/laravel-create-webhook.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=f551f634ded549840bc894726ca3483b)

### CSRF protection

Webhook requests from Resend need to bypass Laravel's CSRF protection. Be sure to list the URI as an exception in your application's `App\Http\Middleware\VerifyCsrfToken` middleware or list the route outside of the web middleware group:

```php theme={"theme":{"light":"github-light","dark":"vesper"}}
protected $except = [
    'resend/*',
];
```

### Verifying webhook signatures

To enable webhook verification, ensure that the `RESEND_WEBHOOK_SECRET` environment variable is set in your application's `.env` file. The **Signing secret** can be retrieved from your [Resend dashboard](https://resend.com/webhooks).

## Examples

> [card] [Email Sending](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/EmailController.php)
>
> Basic, scheduled, attachments, CID, templates, and prevent threading

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/WebhookController.php)
>
> Handle webhook events

> [card] [Inbound Email](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/InboundController.php)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/DoubleOptinController.php)
>
> Double opt-in subscription flow

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/AudienceController.php)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/DomainController.php)
>
> Create and manage sending domains


# Send emails using Laravel with SMTP
Source: https://resend.com/docs/send-with-laravel-smtp

Learn how to send your first email using Laravel with SMTP.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Setup your environment**

First, configure your Resend SMTP details in your application's `.env` file:

```ini .env theme={"theme":{"light":"github-light","dark":"vesper"}}
MAIL_MAILER=smtp
MAIL_HOST=smtp.resend.com
MAIL_PORT=587
MAIL_USERNAME=resend
MAIL_PASSWORD=re_xxxxxxxxx
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=onboarding@resend.dev
MAIL_FROM_NAME=Acme
```

**2. Send an email**

Now you're ready to send emails with Laravel's powerful email service. Here's an example of how to send your first email using Resend SMTP:

```php OrderShipmentController.php theme={"theme":{"light":"github-light","dark":"vesper"}}
<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Mail\OrderShipped;
use App\Models\Order;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Mail;

class OrderShipmentController extends Controller
{
    /**
     * Ship the given order.
     */
    public function store(Request $request): RedirectResponse
    {
        $order = Order::findOrFail($request->order_id);

        // Ship the order...

        Mail::to($request->user())->send(new OrderShipped($order));

        return redirect('/orders');
    }
}
```

## Examples

> [card] [Email Sending](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/EmailController.php)
>
> Basic, scheduled, attachments, CID, templates, and prevent threading

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/WebhookController.php)
>
> Handle webhook events

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/DoubleOptinController.php)
>
> Double opt-in subscription flow

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/AudienceController.php)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/laravel-resend-examples/app/Http/Controllers/DomainController.php)
>
> Create and manage sending domains


# Send emails using Liferay with SMTP
Source: https://resend.com/docs/send-with-liferay-smtp

Learn how to integrate Liferay with Resend SMTP.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Get the Resend SMTP credentials**

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

**2. Integrate with Liferay**

After logging into your Liferay instance as the admin user, you'll need to enable the SMTP integration.

1. Navigate to **Control Panel** → **Server Administration** → **Mail**.

![Liferay - SMTP](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/liferay-smtp-1.jpg?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=94e43af6a43bc9fa8ce8cc486eeb4f05)

2. Copy-and-paste the SMTP credentials from Resend to Liferay.

* **Outgoing SMTP Server**: `smtp.resend.com`
* **Outgoing Port**: `465`
* **Enable StartTLS**: `True`
* **User Name**: `resend`
* **Password**: `YOUR_API_KEY`

Make sure to replace `YOUR_API_KEY` with an existing key or create a new [API Key](https://resend.com/api-keys).

For the additional JavaMail properties, you can use:

```
mail.smtp.auth=true
mail.smtp.starttls.enable=true
mail.smtp.starttls.required=true
```


# Send emails using Metabase with SMTP
Source: https://resend.com/docs/send-with-metabase-smtp

Learn how to integrate Metabase with Resend SMTP.

### Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Get the Resend SMTP credentials**

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

**2. Integrate with Metabase SMTP**

After logging into your [Metabase Cloud](https://www.metabase.com/cloud/login) account, you’ll need to enable the SMTP integration.

1. From your Metabase Cloud Admin Panel, go to **Settings > Email** in the left menu. You'll see the form below.

![Metabase Cloud SMTP](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/metabase-smtp-1.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=b11a45255f8f9058f03cebbd604eb4e5)

2. Copy-and-paste the SMTP credentials from Resend to Metabase Cloud. Finally, click the **Save** button and all of your emails will be sent through Resend.

![Metabase Cloud SMTP](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/metabase-smtp-2.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=ca2550e6061a992cc3c9a345eacd4c39)


# Send emails using NextAuth with SMTP
Source: https://resend.com/docs/send-with-nextauth-smtp

Learn how to send your first email using NextAuth.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Install the [NextAuth](https://next-auth.js.org/getting-started/example#install-nextauth) package.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install next-auth
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add next-auth
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add next-auth
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add next-auth
```

Then, install the [Nodemailer](https://www.npmjs.com/package/nodemailer) package.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install nodemailer
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add nodemailer
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add nodemailer
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add nodemailer
```

**2. Configure SMTP credentials**

Add your Resend SMTP crendentials in your application's `.env` file:

```ini .env theme={"theme":{"light":"github-light","dark":"vesper"}}
EMAIL_SERVER_USER=resend
EMAIL_SERVER_PASSWORD=YOUR_API_KEY
EMAIL_SERVER_HOST=smtp.resend.com
EMAIL_SERVER_PORT=465
EMAIL_FROM=onboarding@resend.dev
```

**3. Configure Email Provider**

Finally, in your \[...nextauth].js file (typically located in pages/api/auth), configure the Email provider with your SMTP settings:

```js index.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import NextAuth from 'next-auth';
import EmailProvider from 'next-auth/providers/email';
import nodemailer from 'nodemailer';

export default NextAuth({
  providers: [
    EmailProvider({
      server: {
        host: process.env.EMAIL_SERVER_HOST,
        port: process.env.EMAIL_SERVER_PORT,
        auth: {
          user: process.env.EMAIL_SERVER_USER,
          pass: process.env.EMAIL_SERVER_PASSWORD,
        },
      },
      from: process.env.EMAIL_FROM,
    }),
    // ... other providers as needed
  ],
  // ... any other NextAuth.js configs
});
```


# Send emails with Next.js
Source: https://resend.com/docs/send-with-nextjs

Learn how to send your first email using Next.js and the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

Prefer watching a video? Check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/yLvhWObBp9I)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Create an email template**

Start by creating your email template on `components/email-template.tsx`.

```tsx components/email-template.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import * as React from 'react';

interface EmailTemplateProps {
  firstName: string;
}

export function EmailTemplate({ firstName }: EmailTemplateProps) {
  return (
    <div>
      <h1>Welcome, {firstName}!</h1>
    </div>
  );
}
```

**3. Send email using React**

Create a route file under `app/api/send/route.ts` (or `pages/api/send.ts` if you're using [Pages Router](https://nextjs.org/docs/pages/building-your-application/routing/api-routes)).

Import the React email template and send an email using the `react` parameter.

```ts app/api/send/route.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { EmailTemplate } from '../../../components/email-template';
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export async function POST() {
  try {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello world',
      react: EmailTemplate({ firstName: 'John' }),
    });

    if (error) {
      return Response.json({ error }, { status: 500 });
    }

    return Response.json(data);
  } catch (error) {
    return Response.json({ error }, { status: 500 });
  }
}
```

```ts pages/api/send.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import type { NextApiRequest, NextApiResponse } from 'next';
import { EmailTemplate } from '../../components/email-template';
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export default async (req: NextApiRequest, res: NextApiResponse) => {
  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Hello world',
    react: EmailTemplate({ firstName: 'John' }),
  });

  if (error) {
    return res.status(400).json(error);
  }

  res.status(200).json(data);
};
```

## Examples

> [card] [Next.js (TypeScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript)
>
> Full-stack Next.js app with TypeScript

> [card] [Next.js (JavaScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript)
>
> Full-stack Next.js app with JavaScript

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/attachments)
>
> Send emails with file attachments

> [card] [React Email](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/react-email)
>
> Send emails with React Email components

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/templates)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/scheduling)
>
> Schedule emails for future delivery

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/double-optin)
>
> Double opt-in subscription flow

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/inbound)
>
> Receive and process inbound emails

> [card] [Prevent Threading](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/prevent-threading)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/domains)
>
> Create and manage sending domains

> [card] [Better Auth](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/better-auth)
>
> Email authentication with Better Auth


# Send emails with Node.js
Source: https://resend.com/docs/send-with-nodejs

Learn how to send your first email using the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Set your API key**

Store your API key in an environment variable in your `.env` file.

```sh .env theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY=re_xxxxxxxxx
```

Pass it to the constructor with `process.env.RESEND_API_KEY`. See [Create an API key](/docs/create-an-api-key) for the full setup.

**3. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```js server.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

(async function () {
  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Hello World',
    html: '<strong>It works!</strong>',
  });

  if (error) {
    return console.error({ error });
  }

  console.log({ data });
})();
```

## Examples

> [card] [Express (TypeScript)](https://github.com/resend/resend-examples/tree/main/express-resend-examples/typescript)
>
> Full Express app with TypeScript

> [card] [Express (JavaScript)](https://github.com/resend/resend-examples/tree/main/express-resend-examples/javascript)
>
> Full Express app with JavaScript

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/with-attachments.ts)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/with-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/scheduled-send.ts)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/audiences.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/domains.ts)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/inbound.ts)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/express-resend-examples/typescript/examples/double-optin-subscribe.ts)
>
> Double opt-in subscription flow


# Send emails using Nodemailer with SMTP
Source: https://resend.com/docs/send-with-nodemailer-smtp

Learn how to send your first email using Nodemailer with SMTP.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

**1. Install**

Get the [Nodemailer](https://www.npmjs.com/package/nodemailer) package.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install nodemailer
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add nodemailer
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add nodemailer
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add nodemailer
```

**2. Send email using SMTP**

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

Then use these credentials to create a transport:

```js index.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import nodemailer from 'nodemailer';

async function main() {
  const transporter = nodemailer.createTransport({
    host: 'smtp.resend.com',
    secure: true,
    port: 465,
    auth: {
      user: 'resend',
      pass: 're_xxxxxxxxx',
    },
  });

  const info = await transporter.sendMail({
    from: 'onboarding@resend.dev',
    to: 'delivered@resend.dev',
    subject: 'Hello World',
    html: '<strong>It works!</strong>',
  });

  console.log('Message sent: %s', info.messageId);
}

main().catch(console.error);
```

## Examples

> [card] [Nodemailer SMTP Example](https://github.com/resend/resend-nodemailer-smtp-example)
>
> See the full source code.


# Send emails with Nuxt
Source: https://resend.com/docs/send-with-nuxt

Learn how to send your first email using Nuxt and the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Send email using HTML**

Create a [Server Route](https://nuxt.com/docs/guide/directory-structure/server) under `server/api/send.ts`.

The easiest way to send an email is by using the `html` parameter.

```ts server/api/send.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export default defineEventHandler(async () => {
  const response = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Hello world',
    html: '<strong>It works!</strong>',
  });

  if (response.error) {
    throw createError({
      statusCode: 500,
      message: 'Error sending email',
    });
  }

  return response;
});
```

## Examples

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send.post.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send-attachment.post.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send-cid.post.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send-template.post.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/send-scheduled.post.ts)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/nuxt-resend-examples/typescript/server/api/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/domains.post.ts)
>
> Create and manage sending domains

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/nuxt-resend-examples/typescript/server/api/webhook.post.ts)
>
> Handle webhook events


# Send emails with Phoenix
Source: https://resend.com/docs/send-with-phoenix

Learn how to send your first email using Phoenix and the Resend Elixir SDK.

> [!NOTE]
>
> This guides utilizes an [open source
> library](https://github.com/elixir-saas/resend-elixir) contributed by a
> community member. It's not developed, maintained, or supported by Resend
> directly.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Install by adding `resend` to your list of dependencies in `mix.exs`:

```elixir mix.exs theme={"theme":{"light":"github-light","dark":"vesper"}}
def deps do
  [
    {:resend, "~> 0.4.5"}
  ]
end
```

**2. Send email using Swoosh**

This library includes a Swoosh adapter to make using Resend with a new Phoenix project straightforward. Configure your Mailer:

```elixir theme={"theme":{"light":"github-light","dark":"vesper"}}
config :my_app, MyApp.Mailer,
  adapter: Resend.Swoosh.Adapter,
  api_key: System.fetch_env!("RESEND_API_KEY")
```

If you're configuring your app for production, configure your adapter in `prod.exs`, and your API key from the environment in `runtime.exs`:

```elixir prod.exs theme={"theme":{"light":"github-light","dark":"vesper"}}
config :my_app, MyApp.Mailer, adapter: Resend.Swoosh.Adapter
```

```elixir runtime.exs theme={"theme":{"light":"github-light","dark":"vesper"}}
config :my_app, MyApp.Mailer, api_key: "re_xxxxxxxxx"
```

## Examples

> [card] [Phoenix App](https://github.com/resend/resend-examples/tree/main/elixir-resend-examples/phoenix_app)
>
> Full Phoenix web framework application

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/basic_send.exs)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/with_attachments.exs)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/with_template.exs)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/scheduled_send.exs)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/audiences.exs)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/domains.exs)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/elixir-resend-examples/examples/inbound.exs)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/elixir-resend-examples/examples/double_optin)
>
> Double opt-in subscription flow


# Send emails with PHP
Source: https://resend.com/docs/send-with-php

Learn how to send your first email using the Resend PHP SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

Prefer watching a video? Check out this video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/vJRJ7b4QJHw)

## Guide

**1. Install**

Get the Resend PHP SDK.

```bash Composer theme={"theme":{"light":"github-light","dark":"vesper"}}
composer require resend/resend-php
```

**2. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```php index.php theme={"theme":{"light":"github-light","dark":"vesper"}}
<?php

require __DIR__ . '/vendor/autoload.php';

$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'html' => '<strong>it works!</strong>',
]);
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/send)
>
> Basic, batch, and prevent-threading send

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/attachments)
>
> File attachments and inline images (CID)

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/scheduling)
>
> Schedule emails for future delivery

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/templates)
>
> Send emails using Resend hosted templates

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/double-optin)
>
> Double opt-in subscription flow

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/inbound)
>
> Receive and process inbound emails

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/domains)
>
> Create and manage sending domains

> [card] [Symfony App](https://github.com/resend/resend-examples/tree/main/php-resend-examples/symfony_app)
>
> Full Symfony web application


# Send emails using PHPMailer with SMTP
Source: https://resend.com/docs/send-with-phpmailer-smtp

Learn how to send your first email using PHPMailer with SMTP.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the [PHPMailer](https://github.com/PHPMailer/PHPMailer) package.

```bash php theme={"theme":{"light":"github-light","dark":"vesper"}}
composer require phpmailer/phpmailer
```

**2. Send email using SMTP**

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `587`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

Then use these credentials to send with PHPMailer:

```php theme={"theme":{"light":"github-light","dark":"vesper"}}
<?php

// Include Composer autoload file to load PHPMailer classes
require __DIR__ . '/vendor/autoload.php';

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

$mail = new PHPMailer(true);

try {
    $mail->isSMTP();
    $mail->Host = 'smtp.resend.com';
    $mail->SMTPAuth = true;
    $mail->Username = 'resend';
    $mail->Password = 're_xxxxxxxxx';
    $mail->SMTPSecure = 'tls';
    $mail->Port = 587;

    // Set email format to HTML
    $mail->isHTML(true);

    $mail->setFrom('onboarding@resend.dev');
    $mail->addAddress('delivered@resend.dev');
    $mail->Subject = 'Hello World';
    $mail->Body = '<strong>It works!</strong>';

    $mail->send();

    // Log the successfully sent message
    echo 'Email successfully sent';
} catch (Exception $e) {
    // Log the detailed error for debugging
    error_log('Mailer Error: ' . $mail->ErrorInfo);
    // Show a generic error message to the user
    echo 'There was an error sending the email.';
}
```

## Examples

> [card] [PHPMailer SMTP Example](https://github.com/resend/resend-phpmailer-smtp-example)
>
> See the full source code.


# Send emails with Python
Source: https://resend.com/docs/send-with-python

Learn how to send your first email using the Resend Python SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Python SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Python SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Python Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```python theme={"theme":{"light":"github-light","dark":"vesper"}}
resend.api_key = os.environ["RESEND_API_KEY"]
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
pip install resend
```

### **Send an Email**

```python theme={"theme":{"light":"github-light","dark":"vesper"}}
import os
import resend
from resend.exceptions import ResendError

resend.api_key = os.environ["RESEND_API_KEY"]

params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Hello World",
    "html": "<strong>It works!</strong>",
}

try:
    email = resend.Emails.send(params)
    print(email)  # {'id': '49a3999c-...'}
except ResendError as error:
    print(error)
```

### Error Handling

`resend.Emails.send()` **raises** an exception on failure — it does not return an error object. Catch `resend.exceptions.ResendError` (or a specific subclass) rather than checking a return value:

```python theme={"theme":{"light":"github-light","dark":"vesper"}}
from resend.exceptions import (
    ResendError,
    ValidationError,
    RateLimitError,
    InvalidApiKeyError,
)

try:
    email = resend.Emails.send(params)
except RateLimitError as error:
    ...  # back off and retry
except ValidationError as error:
    ...  # fix the request params
except ResendError as error:
    ...  # catch-all: error.code, error.message, error.error_type
```

A missing required argument (e.g. no `to` field) raises a plain `ValueError`, not a `ResendError`.

### Rate Limiting

The default rate limit is 10 requests per second per team. Exceeding it raises `resend.exceptions.RateLimitError`. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: pass an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

Unlike Node's single-object `idempotencyKey` field, Python's `send()` takes idempotency as a **second, separate argument**:

```python theme={"theme":{"light":"github-light","dark":"vesper"}}
options: resend.Emails.SendOptions = {"idempotency_key": "welcome-user/123456789"}

email = resend.Emails.send(params, options)
```

***

## **2. Complete `Emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `str` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `str \| List[str]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `str` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `str` | HTML version of the email body. |
| `text` | `str` | Plain text version. Auto-generated from `html` if omitted. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `str \| List[str]` | Carbon copy recipients. |
| `bcc` | `str \| List[str]` | Blind carbon copy recipients. |
| `reply_to` | `str \| List[str]` | Reply-to address(es). |
| `scheduled_at` | `str` | Schedule delivery time. ISO 8601 (e.g. `2024-08-05T11:52:01.858Z`). |
| `headers` | `Dict[str, str]` | Custom email headers as key-value pairs. |
| `tags` | `List[Tag]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `List[Attachment \| RemoteAttachment]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template["id"]` | `str` | Published template identifier. |
| `template["variables"]` | `Dict[str, str \| int]` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html` or `text`.

### **Response**

A successful call returns a `resend.Emails.SendResponse`:

```python theme={"theme":{"light":"github-light","dark":"vesper"}}
{"id": "49a3999c-..."}
```

A failed call raises a `resend.exceptions.ResendError` subclass — it does not return a value.

***

## **3. Async Support**

Every resource has both a sync and an async method. Use `send_async` (built on `httpx`) inside `async def` code such as FastAPI route handlers:

```python theme={"theme":{"light":"github-light","dark":"vesper"}}
import resend
from resend.exceptions import ResendError

resend.api_key = os.environ["RESEND_API_KEY"]

async def send_welcome_email():
    try:
        email = await resend.Emails.send_async(params)
        return email
    except ResendError as error:
        raise
```

`send_async` requires `httpx` to be installed (`pip install resend[async]`, or just have `httpx` present).

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Set `resend.api_key`** before calling any SDK method.
3. **Wrap `resend.Emails.send()` in `try`/`except`** and catch `resend.exceptions.ResendError` (or a specific subclass) — the SDK raises on failure, it does not return `{data, error}`.
4. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
5. **Check the project for an existing package/dependency manager** (pip, poetry, uv) and use that to install the SDK.
6. **Use snake\_case** for SDK parameters (`reply_to`, `scheduled_at`), not camelCase.
7. **Use `send_async`** instead of `send` inside async code (e.g. FastAPI handlers).

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** assume `resend.Emails.send()` returns an error object — it raises an exception. A bare, unhandled call will crash on failure.
3. **Do not** use camelCase parameter names (`replyTo`, `scheduledAt`) — the Python SDK uses snake\_case (`reply_to`, `scheduled_at`).
4. **Do not** send `html` or `text` alongside `template` — these are mutually exclusive.
5. **Do not** pass an idempotency key inside `params` — it belongs in the separate `options` argument: `send(params, options)`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```python theme={"theme":{"light":"github-light","dark":"vesper"}}
params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Invoice attached",
    "html": "<p>See attached invoice.</p>",
    "attachments": [
        {
            "filename": "invoice.pdf",
            "content": list(invoice_bytes),
        }
    ],
}
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduled_at` parameter. Accepts ISO 8601.

```python theme={"theme":{"light":"github-light","dark":"vesper"}}
params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Reminder",
    "html": "<p>This is your reminder.</p>",
    "scheduled_at": "2026-12-25T09:00:00Z",
}
```

### **Tags for Tracking**

```python theme={"theme":{"light":"github-light","dark":"vesper"}}
params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Welcome",
    "html": "<p>Welcome aboard!</p>",
    "tags": [
        {"name": "category", "value": "welcome"},
        {"name": "user_id", "value": "12345"},
    ],
}
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `resend` imported, and is `resend.api_key` set from an environment variable?
2. **Error Handling**: Is `resend.Emails.send()` wrapped in `try`/`except` catching `resend.exceptions.ResendError`?
3. **Async**: Is `send_async` used instead of `send` inside `async def` code?
4. **Parameters**: Are all parameter names in snake\_case?
5. **Idempotency**: If used, is the idempotency key passed as a separate `options` argument, not inside `params`?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides at [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Python SDK.

```bash Pip theme={"theme":{"light":"github-light","dark":"vesper"}}
pip install resend
```

**2. Set your API key**

Store your API key in an environment variable in your `.env` file.

```sh .env theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY=re_xxxxxxxxx
```

Access it with `os.environ["RESEND_API_KEY"]`. See [Create an API key](/docs/create-an-api-key) for the full setup.

**3. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```py index.py theme={"theme":{"light":"github-light","dark":"vesper"}}
import os
import resend
from resend.exceptions import ResendError

resend.api_key = os.environ["RESEND_API_KEY"]

params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<strong>it works!</strong>",
}

try:
    email = resend.Emails.send(params)
    print(email)
except ResendError as error:
    print(error)
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/basic_send.py)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_attachments.py)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/with_template.py)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/scheduled_send.py)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/audiences.py)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/domains.py)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/inbound.py)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/double_optin_subscribe.py)
>
> Double opt-in subscription flow

> [card] [Flask App](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/flask_app.py)
>
> Full Flask web application

> [card] [FastAPI App](https://github.com/resend/resend-examples/blob/main/python-resend-examples/examples/fastapi_app.py)
>
> Full FastAPI web application

> [card] [Django App](https://github.com/resend/resend-examples/tree/main/python-resend-examples/django_app)
>
> Full Django web application


# Send emails with Rails
Source: https://resend.com/docs/send-with-rails

Learn how to send your first email using Rails and the Resend Ruby SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Ruby SDK.

```bash RubyGems theme={"theme":{"light":"github-light","dark":"vesper"}}
gem install resend
```

```bash Gemfile theme={"theme":{"light":"github-light","dark":"vesper"}}
gem 'resend'
```

**2. Send email using Rails Action Mailer**

This gem can be used as an Action Mailer delivery method.

First, let's update or create your mailer initializer file with your Resend API Key.

```rb config/initializers/mailer.rb theme={"theme":{"light":"github-light","dark":"vesper"}}
Resend.api_key = "re_xxxxxxxxx"
```

Add these lines of code into your environment config file.

```rb config/environments/environment.rb theme={"theme":{"light":"github-light","dark":"vesper"}}
config.action_mailer.delivery_method = :resend
```

Then create a `UserMailer` class definition.

```rb app/mailers/user_mailer.rb theme={"theme":{"light":"github-light","dark":"vesper"}}
class UserMailer < ApplicationMailer
  default from: 'Acme <onboarding@resend.dev>' # this domain must be verified with Resend
  def welcome_email
    @user = params[:user]
    @url = 'http://example.com/login'
    mail(to: ["delivered@resend.dev"], subject: 'hello world')
  end
end
```

And create your ERB email template.

```html app/views/user_mailer/welcome_email.html.erb theme={"theme":{"light":"github-light","dark":"vesper"}}
<!doctype html>
<html>
  <head>
    <meta content="text/html; charset=UTF-8" http-equiv="Content-Type" />
  </head>
  <body>
    <h1>Welcome to example.com, <%= @user.name %></h1>
    <p>You have successfully signed up to example.com,</p>
    <p>To log in to the site, just follow this link: <%= @url %>.</p>
    <p>Thanks for joining and have a great day!</p>
  </body>
</html>
```

Initialize your `UserMailer` class. This returns an `ActionMailer::MessageDelivery` instance.

```rb theme={"theme":{"light":"github-light","dark":"vesper"}}
u = User.new name: "derich"
mailer = UserMailer.with(user: u).welcome_email

# => #<ActionMailer::MessageDelivery:153700, @mail_message=#<Mail::Message...>, @processed_mailer=...>
```

Finally, you can now send emails using the `deliver_now!` method:

```rb theme={"theme":{"light":"github-light","dark":"vesper"}}
mailer.deliver_now!

# => {:id=>"a193c81e-9ac5-4708-a569-5caf14220539", :from=>....}
```

## Examples

> [card] [Rails App](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/rails_app)
>
> Full Rails web application

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/basic_send.rb)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/with_attachments.rb)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/with_template.rb)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/scheduled_send.rb)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/audiences.rb)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/domains.rb)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/inbound.rb)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples/double_optin)
>
> Double opt-in subscription flow


# Send emails using Rails with SMTP
Source: https://resend.com/docs/send-with-rails-smtp

Learn how to integrate Rails with Resend SMTP.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Setup your environment**

Add these lines of code into your environment config file.

```rb config/environments/environment.rb theme={"theme":{"light":"github-light","dark":"vesper"}}
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = {
  :address   => 'smtp.resend.com',
  :port      => 465,
  :user_name => 'resend',
  :password  => ENV['RESEND_API_KEY'],
  :tls => true
}
```

**2. Send email using Rails Action Mailer**

Then create a `UserMailer` class definition.

```rb app/mailers/user_mailer.rb theme={"theme":{"light":"github-light","dark":"vesper"}}
class UserMailer < ApplicationMailer
  default from: 'Acme <onboarding@resend.dev>' # this domain must be verified with Resend
  def welcome_email
    @user = params[:user]
    @url = 'http://example.com/login'
    mail(to: ["delivered@resend.dev"], subject: 'hello world')
  end
end
```

And create your ERB email template.

```html app/views/user_mailer/welcome_email.html.erb theme={"theme":{"light":"github-light","dark":"vesper"}}
<!doctype html>
<html>
  <head>
    <meta content="text/html; charset=UTF-8" http-equiv="Content-Type" />
  </head>
  <body>
    <h1>Welcome to example.com, <%= @user.name %></h1>
    <p>You have successfully signed up to example.com,</p>
    <p>To log in to the site, just follow this link: <%= @url %>.</p>
    <p>Thanks for joining and have a great day!</p>
  </body>
</html>
```

Initialize your `UserMailer` class. This returns an `ActionMailer::MessageDelivery` instance.

```rb theme={"theme":{"light":"github-light","dark":"vesper"}}
u = User.new name: "derich"
mailer = UserMailer.with(user: u).welcome_email

# => #<ActionMailer::MessageDelivery:153700, @mail_message=#<Mail::Message...>, @processed_mailer=...>
```

Finally, you can now send emails using the `deliver_now!` method:

```rb theme={"theme":{"light":"github-light","dark":"vesper"}}
mailer.deliver_now!

# => {:id=>"a193c81e-9ac5-4708-a569-5caf14220539", :from=>....}
```

## Examples

> [card] [Rails SMTP Example](https://github.com/resend/resend-rails-smtp-example)
>
> See the full source code.


# Send emails with Railway
Source: https://resend.com/docs/send-with-railway

Learn how to send your first email using Railway and the Resend Node.js SDK.

[Railway](https://railway.com/?referralCode=resend) enables you to focus on building product instead of managing infrastructure, automatically scaling to support your needs as you grow.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

We've created a [Resend template](https://railway.com/deploy/resend?referralCode=resend\&utm_medium=integration\&utm_source=template\&utm_campaign=generic) using the Resend Node.js SDK as an introduction to using Resend on Railway.

To get started, you deploy the template to Railway.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/resend?referralCode=resend\&utm_medium=integration\&utm_source=template\&utm_campaign=generic)

![Deploy button highlighted on Railway](https://mintcdn.com/resend/UGYfPeFBYurSSqVy/images/send-with-railway.png?fit=max\&auto=format\&n=UGYfPeFBYurSSqVy\&q=85\&s=a4b37d9be58e4df72a9eec8e89352e1c)

**2. Add your API key**

[Add an API key](https://resend.com/api-keys) from Resend and click **Deploy**.

![Template modal with API key field highlighted](https://mintcdn.com/resend/UGYfPeFBYurSSqVy/images/send-with-railway-1.png?fit=max\&auto=format\&n=UGYfPeFBYurSSqVy\&q=85\&s=0efcfbf778a0193a8c9aa353a07635b6)

**3. Send your first email**

Once your deployment finishes, click the deploy URL to open the app and send your first email.

![Deployment link highlighted](https://mintcdn.com/resend/UGYfPeFBYurSSqVy/images/send-with-railway-2.png?fit=max\&auto=format\&n=UGYfPeFBYurSSqVy\&q=85\&s=c4a9f0838a4efb406d349c4e815c1c80)

While this example uses the [Resend Node.js SDK](https://www.npmjs.com/package/@resend/node), you can add Resend using [any of our Official SDKs](https://resend.com/docs/sdks) that Railway supports.

> [!NOTE]
>
> Keep in mind that as a basic project, this template sends an email with your
> account each time someone visits your deployment URL, so share the link with
> discretion.

You can also [set up the project locally](https://docs.railway.com/develop/cli) and make changes to the projectusing the Railway CLI.

## Examples

> [card] [Railway Template](https://github.com/resend/resend-node-railway-starter)
>
> See the full source code.


# Send emails with RedwoodJS
Source: https://resend.com/docs/send-with-redwoodjs

Learn how to send your first email using Redwood.js and the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

### Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn workspace api add resend
```

**2. Send email using HTML**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn rw g function send
```

The easiest way to send an email is by using the `html` parameter.

```ts api/src/functions/send/send.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import type { APIGatewayEvent, Context } from 'aws-lambda';

const resend = new Resend('re_xxxxxxxxx');

export const handler = async (event: APIGatewayEvent, context: Context) => {
  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<strong>it works!</strong>',
  });

  if (error) {
    return {
      statusCode: 500,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ error }),
    };
  }

  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ data }),
  };
};
```

## Examples

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/sendAttachment.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/sendCid.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/sendTemplate.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/sendScheduled.ts)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/audiencesContacts.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/domains.ts)
>
> Create and manage sending domains

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/webhook.ts)
>
> Handle webhook events

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/redwoodjs-resend-examples/typescript/api/src/functions/doubleOptinSubscribe.ts)
>
> Double opt-in subscription flow


# Send emails with Remix
Source: https://resend.com/docs/send-with-remix

Learn how to send your first email using Remix and the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Send email using HTML**

Create a [Resource Route](https://remix.run/docs/en/1.16.1/guides/resource-routes) under `app/routes/send.ts`.

The easiest way to send an email is by using the `html` parameter.

```ts app/routes/send.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { json } from '@remix-run/node';
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export const loader = async () => {
  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Hello world',
    html: '<strong>It works!</strong>',
  });

  if (error) {
    return json({ error }, 400);
  }

  return json(data, 200);
};
```

## Examples

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send-attachment.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send-cid.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.send-scheduled.ts)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.audiences.contacts.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.domains.ts)
>
> Create and manage sending domains

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/api.webhook.ts)
>
> Handle webhook events

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/double-optin.tsx)
>
> Double opt-in subscription flow

> [card] [Inbound](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/inbound.tsx)
>
> Receive and process inbound emails

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/remix-resend-examples/typescript/app/routes/prevent-threading.tsx)
>
> Prevent email threading on Gmail


# Send emails using Retool with SMTP
Source: https://resend.com/docs/send-with-retool-smtp

Learn how to integrate Retool with Resend SMTP.

### Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Get the Resend SMTP credentials**

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

**2. Integrate with Retool SMTP**

Log into your [Retool](https://retool.com) account and create a new SMTP Resource.

1. Go to **Resources** and click **Create New**

![Retool SMTP - Create new Resources](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/retool-smtp-1.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=c6edda6c2512e895bfec5b7e47627d96)

2. Search for **SMTP** and select it

![Retool SMTP - Search for SMTP](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/retool-smtp-2.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=b95716d79754f6d2f8cedd6522d8e8f8)

3. Add name and SMTP credentials

![Retool SMTP - Add SMTP credentials](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/retool-smtp-3.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=cbd6221e4b03dfc909f00f966afc4a2a)


# Send emails with Ruby
Source: https://resend.com/docs/send-with-ruby

Learn how to send your first email using the Resend Ruby SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Ruby SDK.

```bash RubyGems theme={"theme":{"light":"github-light","dark":"vesper"}}
gem install resend
```

```bash Gemfile theme={"theme":{"light":"github-light","dark":"vesper"}}
gem 'resend'
```

**2. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```rb index.rb theme={"theme":{"light":"github-light","dark":"vesper"}}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<strong>it works!</strong>"
}

sent = Resend::Emails.send(params)
puts sent
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/basic_send.rb)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/with_attachments.rb)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/with_template.rb)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/scheduled_send.rb)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/audiences.rb)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/domains.rb)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/inbound.rb)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples/double_optin)
>
> Double opt-in subscription flow

> [card] [Sinatra App](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/sinatra_app)
>
> Full Sinatra web application

> [card] [Rails App](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/rails_app)
>
> Full Rails web application


# Send emails with Rust
Source: https://resend.com/docs/send-with-rust

Learn how to send your first email using the Resend Rust SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

First, create a rust project with cargo and `cd` into it.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
cargo init resend-rust-example
cd resend-rust-example
```

Next, add add the Rust Resend SDK as well as [Tokio](https://tokio.rs):

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
cargo add resend-rs
cargo add tokio -F macros,rt-multi-thread
```

The Rust SDK is Async-first so Tokio is needed.

**2. Send email**

```rust theme={"theme":{"light":"github-light","dark":"vesper"}}
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let resend = Resend::new("re_xxxxxxxxx");

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Hello World";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<strong>It works!</strong>");

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

**3. Reading the API key**

Instead of using `Resend::new` and hardcoding the API key, the `RESEND_API_KEY` environment variable
can be used instead. Use `Resend::default()` in that scenario instead.

Another popular option is to use a `.env` file for environment variables. You can use the
[`dotenvy`](https://crates.io/crates/dotenvy) crate for that:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
cargo add dotenvy
```

```rust theme={"theme":{"light":"github-light","dark":"vesper"}}
// main.rs
use dotenvy::dotenv;
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let _env = dotenv().unwrap();

  let resend = Resend::default();

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Hello World";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<strong>It works!</strong>");

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```toml theme={"theme":{"light":"github-light","dark":"vesper"}}
# .env
RESEND_API_KEY=re_xxxxxxxxx
```

## Examples

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/basic_send.rs)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/with_attachments.rs)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/with_template.rs)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/scheduled_send.rs)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/audiences.rs)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/domains.rs)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/inbound.rs)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/rust-resend-examples/examples/double_optin_subscribe.rs)
>
> Double opt-in subscription flow

> [card] [Axum App](https://github.com/resend/resend-examples/tree/main/rust-resend-examples/axum_app)
>
> Full Axum web framework application


# Send emails with Sinatra
Source: https://resend.com/docs/send-with-sinatra

Learn how to send your first email using Sinatra and the Resend Ruby SDK.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Ruby SDK.

```bash RubyGems theme={"theme":{"light":"github-light","dark":"vesper"}}
gem install resend
```

```bash Gemfile theme={"theme":{"light":"github-light","dark":"vesper"}}
gem 'resend'
```

**2. Send email using HTML**

The easiest way to send an email is by using the `html` parameter.

```rb index.rb theme={"theme":{"light":"github-light","dark":"vesper"}}
require "sinatra"
require "resend"

set :port, 5000
set :bind, "0.0.0.0"

Resend.api_key = ENV["RESEND_API_KEY"]

get "/" do

  content_type :json

  params = {
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<strong>it works!</strong>',
  }

  Resend::Emails.send(params).to_hash.to_json
end
```

## Examples

> [card] [Sinatra App](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/sinatra_app)
>
> Full Sinatra web application

> [card] [Basic Send](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/basic_send.rb)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/with_attachments.rb)
>
> Send emails with file attachments

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/with_template.rb)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/scheduled_send.rb)
>
> Schedule emails for future delivery

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/audiences.rb)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/domains.rb)
>
> Create and manage sending domains

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/blob/main/ruby-resend-examples/examples/inbound.rb)
>
> Receive and process inbound emails

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples/double_optin)
>
> Double opt-in subscription flow


# Send emails with SMTP
Source: https://resend.com/docs/send-with-smtp

Learn how to integrate Resend via SMTP.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

Prefer watching a video? Check out our video walkthrough below.

[YouTube video player](https://www.youtube.com/embed/MM1JE6-inmc)

## SMTP Settings

When configuring your SMTP integration, use the following settings:

* **Host**: `smtp.resend.com`
* **Port**: `25`, `465`, `587`, `2465`, or `2587`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

Ports help to instruct the type of security you want to use in your SMTP connection.

| Type | Port | Security |
| - | - | - |
| SMTPS | `465`, `2465` | Implicit SSL/TLS (Immediately connects via SSL/TLS) |
| STARTTLS | `25`, `587`, `2587` | Explicit SSL/TLS (First connects via plaintext, then upgrades to SSL/TLS) |

## Idempotency Key

Idempotency keys are used to prevent duplicate emails. You can add the `Resend-Idempotency-Key` header to your emails sent with SMTP to prevent duplicate emails.

```yaml SMTP {4} theme={"theme":{"light":"github-light","dark":"vesper"}}
From: Acme <onboarding@resend.dev>
To: delivered@resend.dev
Subject: hello world
Resend-Idempotency-Key: welcome-user/123456789

<p>it works!</p>
```

Learn more about [idempotency keys](/docs/dashboard/emails/idempotency-keys).

## Custom Headers

If your SMTP client supports it, you can add custom headers to your emails.

Here are some common use cases for custom headers:

* Prevent threading on Gmail with the `X-Entity-Ref-ID` header
* Include a shortcut for users to unsubscribe with the `List-Unsubscribe` header

## FAQ

Once configured, you can start sending emails via SMTP. Below are some frequently asked questions:

> [accordion] What if I need logs from the server to debug?
>
> We currently don't provide SMTP server logs for debugging. If you run into
> issues, please [reach out to support](https://resend.com/help).

> [accordion] Where do I see the emails sent with SMTP?
>
> Emails sent with SMTP will show in your [emails
> table](https://resend.com/emails).

> [accordion] Does the rate limit apply when sending with SMTP?
>
> Yes, the rate limit is the [same as the
> API](https://resend.com/docs/api-reference/introduction#rate-limit).


# Send emails with Supabase Edge Functions
Source: https://resend.com/docs/send-with-supabase-edge-functions

Learn how to send your first email using Supabase Edge Functions.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

Make sure you have the latest version of the [Supabase CLI](https://supabase.com/docs/guides/cli#installation) installed.

## Guide

**1. Create Supabase function**

Create a new function locally:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
supabase functions new resend
```

**2. Edit the handler function**

Paste the following code into the `index.ts` file:

```ts index.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
const RESEND_API_KEY = Deno.env.get('RESEND_API_KEY');

const handler = async (_request: Request): Promise<Response> => {
  const res = await fetch('https://api.resend.com/emails', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${RESEND_API_KEY}`,
    },
    body: JSON.stringify({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'hello world',
      html: '<strong>it works!</strong>',
    }),
  });

  const data = await res.json();

  return new Response(JSON.stringify(data), {
    status: 200,
    headers: {
      'Content-Type': 'application/json',
    },
  });
};

Deno.serve(handler);
```

**3. Deploy and send email**

Run function locally:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
supabase functions start
supabase functions serve resend --no-verify-jwt
```

Deploy function to Supabase:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
supabase functions deploy resend
```

Open the endpoint URL to send an email:

![Supabase Edge Functions - Deploy Function](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/supabase-edge-functions-deploy-function.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=e28cab375d10a57f712e77ff3c888005)

## Examples

> [card] [Supabase Edge Functions Example](https://github.com/resend/resend-supabase-edge-functions-example)
>
> See the full source code.


# Send emails using Supabase with SMTP
Source: https://resend.com/docs/send-with-supabase-smtp

Learn how to integrate Supabase Auth with Resend SMTP.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Get the Resend SMTP credentials**

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

**2. Integrate with Supabase SMTP**

After logging into your Supabase account, you'll need to enable the SMTP integration.

1. Go to your Supabase project
2. Click on **Authentication** in the left sidebar
3. Click **Email** under the **Notifications** section
4. Click **SMTP Settings**
5. Add your Sender email and name (these are required fields). For example: `support@example.com` and `ACME Support`.

![Supabase Auth - SMTP Sender email and name settings](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/supabase-auth-smtp-sender-email-name.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=1db59a322b21efb38bc298a5796d32b3)

6. You can copy-and-paste the [SMTP credentials](https://resend.com/settings/smtp) from Resend to Supabase.

![Supabase Auth - SMTP Settings](https://mintcdn.com/resend/OWNnQaVDyqcGyhhN/images/supabase-auth-smtp-settings.png?fit=max\&auto=format\&n=OWNnQaVDyqcGyhhN\&q=85\&s=70c068d96e4f03c7e2f03b6e71219d4f)

After that, you can click the **Save** button and all of your emails will be sent through Resend.


# Send emails with SvelteKit
Source: https://resend.com/docs/send-with-sveltekit

Learn how to send your first email using SvelteKit and the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Send email using HTML**

Create a [+server API route](https://svelte.dev/docs/kit/routing#server) under `src/routes/send/+server.ts`.

The easiest way to send an email is by using the `html` parameter.

```ts src/routes/send/+server.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { RESEND_API_KEY } from '$env/static/private'; // define in your .env file

const resend = new Resend(RESEND_API_KEY);

export async function POST() {
  try {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello world',
      html: '<p>Hello world</p>',
    });

    if (error) {
      return Response.json({ error }, { status: 500 });
    }

    return Response.json({ data });
  } catch (error) {
    return Response.json({ error }, { status: 500 });
  }
}
```

## Examples

> [card] [Send Email](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-attachment)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-cid)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-template)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-scheduled)
>
> Schedule emails for future delivery

> [card] [Prevent Threading](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/send-prevent-threading)
>
> Prevent email threading on Gmail

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/domains)
>
> Create and manage sending domains

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/double-optin)
>
> Double opt-in subscription flow

> [card] [Webhooks](https://github.com/resend/resend-examples/tree/main/sveltekit-resend-examples/typescript/src/routes/api/webhook)
>
> Handle webhook events


# Send emails with Symfony
Source: https://resend.com/docs/send-with-symfony

Learn how to send your first email using the Symfony Resend Mailer Bridge.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Mailer Bridge package.

```bash Composer theme={"theme":{"light":"github-light","dark":"vesper"}}
composer require symfony/resend-mailer
```

If your application relies on Resend webhook events, also install the Symfony Webhook Component.

```bash Composer theme={"theme":{"light":"github-light","dark":"vesper"}}
composer require symfony/webhook
```

**2. Configuring Mailer**

In your `.env.local` file, which you can create if needed, add the following:

```sh theme={"theme":{"light":"github-light","dark":"vesper"}}
MAILER_DSN=resend+api://API_KEY@default
MAILER_RESEND_SECRET=SIGNING_SECRET
```

Replace `API_KEY` with your Resend API key, and `SIGNING_SECRET` with your webhook secret, which can be retrieved from the Resend dashboard after creating a new webhook endpoint (see below).

**3. Send your first email**

In a controller, inject the `Mailer`:

```php theme={"theme":{"light":"github-light","dark":"vesper"}}
public function __construct(
    private readonly MailerInterface $mailer,
) {
}
```

In a controller action, use the `$this->mailer` to send your email:

```php theme={"theme":{"light":"github-light","dark":"vesper"}}
$this->mailer->send(
    (new Email())
        ->from('Acme <onboarding@resend.dev>')
        ->to('delivered@resend.dev')
        ->subject('Hello world')
        ->html('<strong>it works!</strong>')
);
```

Learn more about sending emails with Mailer Component in [Symfony's documentation](https://symfony.com/doc/current/mailer.html#creating-sending-messages).

**4. Receive and handle webhooks**

Thanks to the Webhook Component, you can create a webhook listener.

```php src/Webhook/ResendWebhookListener.php theme={"theme":{"light":"github-light","dark":"vesper"}}
#[AsRemoteEventConsumer('mailer_resend')]
readonly class ResendWebhookListener implements ConsumerInterface
{
    public function __construct(
        #[Autowire(param: 'kernel.project_dir')] private string $projectDir,
    ) {
    }

    public function consume(RemoteEvent $event): void
    {
        if ($event instanceof MailerDeliveryEvent) {
            $this->handleMailDelivery($event);
        } elseif ($event instanceof MailerEngagementEvent) {
            $this->handleMailEngagement($event);
        } else {
            // This is not an email event
            return;
        }
    }

    private function handleMailDelivery(MailerDeliveryEvent $event): void
    {
        // Todo
    }

    private function handleMailEngagement(MailerEngagementEvent $event): void
    {
        // Todo
    }
}
```

Bind your listener to the Webhook routing config:

```yaml config/packages/webhook.yaml theme={"theme":{"light":"github-light","dark":"vesper"}}
framework:
  webhook:
    routing:
      mailer_resend:
        service: 'mailer.webhook.request_parser.resend'
        secret: '%env(MAILER_RESEND_SECRET)%'
```

Next, register your application's webhook endpoint URL (example: `https://{app_domain}/webhook/mailer_resend`) in the [Resend Dashboard](https://resend.com/webhooks):

## Examples

> [card] [Symfony App](https://github.com/resend/resend-examples/tree/main/php-resend-examples/symfony_app)
>
> Full Symfony web application

> [card] [Basic Send](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/send)
>
> Basic, batch, and prevent-threading send

> [card] [Attachments](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/attachments)
>
> File attachments and inline images (CID)

> [card] [Scheduling](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/scheduling)
>
> Schedule emails for future delivery

> [card] [Templates](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/templates)
>
> Send emails using Resend hosted templates

> [card] [Double Opt-in](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/double-optin)
>
> Double opt-in subscription flow

> [card] [Inbound Webhooks](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/inbound)
>
> Receive and process inbound emails

> [card] [Audiences](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/audiences)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/domains)
>
> Create and manage sending domains


# Send emails with TanStack Start
Source: https://resend.com/docs/send-with-tanstack-start

Learn how to send your first email using TanStack Start and the Resend Node.js SDK.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install**

Get the Resend Node.js SDK.

```bash npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

```bash yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add resend
```

```bash pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add resend
```

```bash bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add resend
```

**2. Create an email template**

Start by creating your email template on `src/components/email-template.tsx`.

```tsx src/components/email-template.tsx theme={"theme":{"light":"github-light","dark":"vesper"}}
import * as React from 'react';

interface EmailTemplateProps {
  firstName: string;
}

export function EmailTemplate({ firstName }: EmailTemplateProps) {
  return (
    <div>
      <h1>Welcome, {firstName}!</h1>
    </div>
  );
}
```

**3. Send email using React**

The recommended approach is a [server function](https://tanstack.com/start/latest/docs/framework/react/guide/server-functions), which runs only on the server and can be called from anywhere in your app. If you'd rather expose a REST endpoint, use a [server route](https://tanstack.com/start/latest/docs/framework/react/guide/server-routes) instead.

Import the React email template and send an email using the `react` parameter.

```ts src/utils/send-email.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { createServerFn } from '@tanstack/react-start';
import { Resend } from 'resend';
import { EmailTemplate } from '../components/email-template';

const resend = new Resend(process.env.RESEND_API_KEY);

export const sendEmail = createServerFn({ method: 'POST' }).handler(
  async () => {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello world',
      react: EmailTemplate({ firstName: 'John' }),
    });

    if (error) {
      throw error;
    }

    return data;
  },
);
```

```ts src/routes/api/send.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { createFileRoute } from '@tanstack/react-router';
import { Resend } from 'resend';
import { EmailTemplate } from '../../components/email-template';

const resend = new Resend(process.env.RESEND_API_KEY);

export const Route = createFileRoute('/api/send')({
  server: {
    handlers: {
      POST: async () => {
        const { data, error } = await resend.emails.send({
          from: 'Acme <onboarding@resend.dev>',
          to: ['delivered@resend.dev'],
          subject: 'Hello world',
          react: EmailTemplate({ firstName: 'John' }),
        });

        if (error) {
          return Response.json({ error }, { status: 500 });
        }

        return Response.json(data);
      },
    },
  },
});
```

## Examples

> [card] [TanStack Start (TypeScript)](https://github.com/resend/resend-examples/tree/main/tanstack-resend-examples/typescript)
>
> Full-stack TanStack Start app with TypeScript

> [card] [TanStack Start (JavaScript)](https://github.com/resend/resend-examples/tree/main/tanstack-resend-examples/javascript)
>
> Full-stack TanStack Start app with JavaScript

> [card] [Send Email](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send.ts)
>
> Basic email sending

> [card] [Attachments](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-attachment.ts)
>
> Send emails with file attachments

> [card] [Inline Images (CID)](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-cid.ts)
>
> Embed inline images using CID

> [card] [Templates](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-template.ts)
>
> Send emails using Resend hosted templates

> [card] [Scheduling](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-scheduled.ts)
>
> Schedule emails for future delivery

> [card] [Batch Emails](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/send-batch.ts)
>
> Send multiple emails in a single request

> [card] [Audiences](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/audiences/contacts.ts)
>
> Manage contacts and audiences

> [card] [Domains](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/domains.ts)
>
> Create and manage sending domains

> [card] [Double Opt-in](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/double-optin.tsx)
>
> Double opt-in subscription flow

> [card] [Inbound](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/inbound.tsx)
>
> Receive and process inbound emails

> [card] [Prevent Threading](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/prevent-threading.tsx)
>
> Prevent email threading on Gmail

> [card] [Webhooks](https://github.com/resend/resend-examples/blob/main/tanstack-resend-examples/typescript/src/routes/api/webhook.ts)
>
> Handle webhook events


# Send emails with Vercel Functions
Source: https://resend.com/docs/send-with-vercel-functions

Learn how to send your first email using Vercel Functions.

Use this pre-built prompt to get started faster.

# Send Email with Resend Node.js SDK

**Purpose:** Enforce only the **current** and **correct** instructions for sending emails using the [Resend](https://resend.com/) Node.js SDK.
**Scope:** All AI-generated advice or code related to sending email with Resend must follow these guardrails.

***

## **1. Official Resend Node.js Setup**

### **Prerequisites**

Human must first create an API key and verify their domain at [https://resend.com/domains](https://resend.com/domains).

The API key must be stored in an environment variable called `RESEND_API_KEY`.

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const resend = new Resend('YOUR_RESEND_API_KEY');
```

The domain should be verified at [https://resend.com/domains](https://resend.com/domains) and added to the `from` address.

### **Install the SDK**

Use the project's existing package manager to install the Resend Node.js SDK.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
# or: yarn add resend / pnpm add resend / bun add resend
```

### **Initialize the Client**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend('YOUR_RESEND_API_KEY');
```

### **Send an Email**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
});

if (error) {
  console.error(error);
  return;
}

console.log(data); // { id: '49a3999c-...' }
```

### Rate Limiting

The default rate limit is 10 requests per second per team. If you exceed the rate limit, you'll receive a `429` response error code. If needed, you can request a rate increase by [contacting support](https://resend.com/help).

### Idempotency

Best practice: Add an idempotency key to prevent duplicated emails, which is useful for retrying failed emails safely.

* Should be **unique per API request**
* Idempotency keys expire after **24 hours**
* Have a maximum length of **256 characters**
* Pattern: `<event-type>/<entity-id>`
* Example: `welcome-user/123456789`

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Hello World',
  html: '<strong>It works!</strong>',
  idempotencyKey: 'unique-id',
});
```

***

## **2. Complete `emails.send()` Parameter Reference**

### **Required Parameters**

| Parameter | Type | Description |
| - | - | - |
| `from` | `string` | Sender email address. Supports friendly name format: `"Name <email@domain.com>"` |
| `to` | `string \| string[]` | Recipient email address(es). Maximum 50 addresses. |
| `subject` | `string` | Email subject line. |

### **Content Parameters (at least one required)**

| Parameter | Type | Description |
| - | - | - |
| `html` | `string` | HTML version of the email body. |
| `text` | `string` | Plain text version. Auto-generated from `html` if omitted. |
| `react` | `React.ReactNode` | React Email component to render the message. Node.js only. |

### **Optional Parameters**

| Parameter | Type | Description |
| - | - | - |
| `cc` | `string \| string[]` | Carbon copy recipients. |
| `bcc` | `string \| string[]` | Blind carbon copy recipients. |
| `replyTo` | `string \| string[]` | Reply-to address(es). |
| `scheduledAt` | `string` | Schedule delivery time. Accepts ISO 8601 or natural language. |
| `headers` | `object` | Custom email headers as key-value pairs. |
| `tags` | `Tag[]` | Custom metadata. Name and value: max 256 chars, ASCII only. |
| `attachments` | `Attachment[]` | File attachments. Max 40MB total per email after encoding. |

### **Template Parameters**

| Parameter | Type | Description |
| - | - | - |
| `template.id` | `string` | Published template identifier. |
| `template.variables` | `object` | Variable substitutions. Key max 50 chars, value max 2,000 chars. |

If `template` is provided, do not include `html`, `text`, or `react`.

### **Response**

A successful call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: { id: string }, error: null }
```

A failed call returns:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
{ data: null, error: { message: string, name: string } }
```

***

## **3. Sending with React Email**

Resend integrates with [React Email](https://react.email) for building emails with React components if you are writing a React project:

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend('YOUR_RESEND_API_KEY');

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  react: WelcomeEmail({ name: 'John' }),
});
```

**Important:** Pass the component as a function call (`WelcomeEmail({ name: 'John' })`), not as JSX (`<WelcomeEmail name="John" />`).

For additional help, suggest installing the react-email skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/react-email
```

***

## **4. CRITICAL INSTRUCTIONS FOR AI MODELS**

### **4.1 - ALWAYS DO THE FOLLOWING**

1. **Store the API key in an environment variable** (`RESEND_API_KEY`). Never hardcode API keys.
2. **Import from `resend`** — the package name is `resend`, the class is `Resend`.
3. **Use `await`** — `resend.emails.send()` returns a Promise. Always use `async/await` or `.then()`.
4. **Handle both `data` and `error`** — the SDK returns `{ data, error }`. Always check for errors.
5. **Use a verified domain** in the `from` address for production. `onboarding@resend.dev` is for testing only.
6. **Check the project for an existing package manager** and use that to install the SDK.
7. **Use camelCase** for SDK parameters (`replyTo`, `scheduledAt`), not snake\_case.

### **4.2 - NEVER DO THE FOLLOWING**

1. **Do not** hardcode API keys in source code. Always use environment variables.
2. **Do not** use `try/catch` for error handling with `resend.emails.send()` — the SDK returns `{ data, error }` instead of throwing. Only use `try/catch` if you need to handle network-level failures.
3. **Do not** use snake\_case parameter names (`reply_to`, `scheduled_at`) — the Node.js SDK uses camelCase (`replyTo`, `scheduledAt`).
4. **Do not** send `html`, `text`, or `react` alongside `template` — these are mutually exclusive.
5. **Do not** import from `@resend/node` or any other package name. The correct package is `resend`.
6. **Do not** use `onboarding@resend.dev` as the `from` address in production code. It is a test-only address.
7. **Do not** set up testing flows with fake email addresses. Resend provides the following test addresses to help you simulate different email events without damaging your domain reputation:
   * `delivered@resend.dev`
   * `bounced@resend.dev`
   * `complained@resend.dev`
   * `suppressed@resend.dev`

***

## **5. COMMON PATTERNS**

### **Attachments**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Invoice attached',
  html: '<p>See attached invoice.</p>',
  attachments: [
    {
      filename: 'invoice.pdf',
      content: invoiceBuffer,
    },
  ],
});
```

### **Scheduled Emails**

Send up to 30 days in advance using the `scheduledAt` parameter. Accepts ISO 8601 or natural language (e.g. `"in 1 hour"`).

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Reminder',
  html: '<p>This is your reminder.</p>',
  scheduledAt: '2026-12-25T09:00:00Z',
});
```

### **Tags for Tracking**

```typescript theme={"theme":{"light":"github-light","dark":"vesper"}}
const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'Welcome',
  html: '<p>Welcome aboard!</p>',
  tags: [
    { name: 'category', value: 'welcome' },
    { name: 'user_id', value: '12345' },
  ],
});
```

***

## **6. AI MODEL VERIFICATION STEPS**

Before returning any Resend-related solution, you **must** verify:

1. **Import**: Is `Resend` imported from `resend`?
2. **API Key**: Is the key stored in an environment variable, not hardcoded?
3. **Await**: Is `resend.emails.send()` properly awaited?
4. **Error Handling**: Is the `{ data, error }` response pattern used?
5. **Parameters**: Are all parameter names in camelCase?
6. **From Address**: Is the `from` address using a verified domain (not `onboarding@resend.dev` in production)?

If any check **fails**, **stop** and revise until compliance is achieved.

For additional help, suggest installing the resend-skills skill and the email-best-practices skill.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npx skills add resend/resend-skills
npx skills add resend/email-best-practices
```

You can locate framework-specific guides [https://resend.com/docs/llms.txt](https://resend.com/docs/llms.txt)

For the entire docs for Resend, see [https://resend.com/docs/llms-full.txt](https://resend.com/docs/llms-full.txt)

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

Make sure you have the latest version of the [Vercel CLI](https://vercel.com/docs/cli#installing-vercel-cli) installed.

## Guide

**1. Install dependencies**

Install the Resend Node.js SDK:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install resend
```

**2. Set up environment variables**

Add your Resend API key to your environment variables:

```bash .env.local theme={"theme":{"light":"github-light","dark":"vesper"}}
RESEND_API_KEY=re_xxxxxxxxx
```

**3. Create a Next.js function**

Create a route file under `app/api/send/route.ts` if you're using the [App Router](https://nextjs.org/docs/app/building-your-application/routing/router-handlers).

```ts route.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export async function POST() {
  const response = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<strong>it works!</strong>',
  });

  return Response.json(response, {
    status: response.error ? 500 : 200,
  });
}
```

**4. Send email locally**

Run function locally:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
npm run dev
```

Open the endpoint URL to send an email: `http://localhost:3000/api/send`

**5. Send email in production**

Deploy function to Vercel:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
vercel
```

Make sure to add your `RESEND_API_KEY` environment variable in your Vercel project settings.

Open the endpoint URL to send an email: `https://your-project.vercel.app/api/send`

## Examples

> [card] [Vercel Functions Example](https://github.com/resend/resend-vercel-functions-example)
>
> See the full source code.


# Send emails using WordPress with SMTP
Source: https://resend.com/docs/send-with-wordpress-smtp

Learn how to send your first email using Wordpress.

## Prerequisites

Before you start, you'll need:

* A Resend [API key](/docs/create-an-api-key)
* A [verified domain](/docs/add-a-domain)

## Guide

**1. Install a plugin**

First, you'll need to install and activate the [WP Mail SMTP](https://wordpress.org/plugins/wp-mail-smtp/) plugin. Once the plugin is activated you will see the setup wizard. You can skip this step as we'll guide you through how to configure the plugin for Resend. Click on **Go to the Dashboard** at the bottom of the screen to exit the setup wizard.

![WP Mail SMTP - Setup Wizard](https://mintcdn.com/resend/lyl6PQTYhtWhUjuS/images/wordpress-setup-wizard.png?fit=max\&auto=format\&n=lyl6PQTYhtWhUjuS\&q=85\&s=034e82ed82a43c1cc25e9119995ac558)

**2. Configuration**

From your admin dashboard, visit the **WP Mail SMTP > Settings** page to configure the plugin. Firstly, configure your **From Email**, **From Name**, and **Return Path**. Next, we'll configure the SMTP settings for Resend. Select **Other SMTP** in the **Mailer** section.

![WP Mail SMTP - Settings](https://mintcdn.com/resend/lyl6PQTYhtWhUjuS/images/wordpress-configure.png?fit=max\&auto=format\&n=lyl6PQTYhtWhUjuS\&q=85\&s=12cb502dcffbc76cad7f6bbef00a7f43)

In the **Other SMTP** section, configure the following settings:

* **SMTP Host**: `smtp.resend.com`
* **Encryption**: `SSL`
* **SMTP Port**: `465`
* **Auto TLS**: `ON`
* **Authentication**: `ON`
* **SMTP Username**: `resend`
* **SMTP Password**: `YOUR_API_KEY`

Make sure to replace `YOUR_API_KEY` with an existing key or create a new [API Key](https://resend.com/api-keys).

**3. Sending a test email**

From your admin dashboard, visit the **WP Mail SMTP > Tools** page to send a test email.

![WP Mail SMTP - Send a Test Email](https://mintcdn.com/resend/lyl6PQTYhtWhUjuS/images/wordpress-test-email.png?fit=max\&auto=format\&n=lyl6PQTYhtWhUjuS\&q=85\&s=bffb755f5673f14a03d84d36a4b361ca)


# Send emails with v0 and Resend
Source: https://resend.com/docs/v0-integration

Learn how to add the Resend integration to your v0 project.

[v0](https://v0.dev) by Vercel is a platform for building web sites, tools, apps, and projects via chat. You can add Resend in a v0 project by asking the chat to add email sending with Resend.

The [v0 Resend integration](https://vercel.com/marketplace/resend) automatically sets up a new Resend account, adds a Resend API key to your v0 project's environment variables, configures DNS for Resend, and manages billing through v0.

## Prerequisites

Before you begin, you'll need two things:

1. A Vercel v0 account with a project.
2. A domain purchased through Vercel.

## Guide

> [!NOTE]
>
> Prefer a video guide? [Watch the v0 Resend integration
> video](https://youtu.be/WSSV5Ofpxzc).

**1. Ask v0 to add the Resend integration**

You can ask v0 something like:

```
Add an email capture to my application using Resend. Store the user's email as a Contact in Resend and send them a welcome email.
```

**2. Install the integration**

Click **Install** to add the Resend integration to your v0 project. This will take you to the integration page, where you can follow the instructions to add email to your project.

![Install button called out in v0 chat](https://mintcdn.com/resend/E_8j6xCcW_Abb4jB/images/v0-integration.png?fit=max\&auto=format\&n=E_8j6xCcW_Abb4jB\&q=85\&s=10c51c3fba665a9ef6d108d2a5ccd564)

The integration will automatically set up a new Resend account, add the necessary environment variables to your v0 project, and verify your domain in Resend.

**3. Finish setup**

Once the integration is installed, click **Finish Setup** to complete the setup.

![Finish setup button called out in v0 chat](https://mintcdn.com/resend/E_8j6xCcW_Abb4jB/images/v0-integration-1.png?fit=max\&auto=format\&n=E_8j6xCcW_Abb4jB\&q=85\&s=ee11a0f791b1b3feb401bb63831c32b2)

You'll be taken to the Resend dashboard, where you can confirm the domain has been verified.

Once you've confirmed your domain is verified, return to the v0 chat and tell the chat the domain is verified and which email it should use to send emails on your behalf.


# contact.created
Source: https://resend.com/docs/webhooks/contacts/created

Received when a contact is created.

Event triggered whenever a **contact was successfully created**.

*Note: When importing multiple contacts using CSV, these events won't be triggered. [Contact support](https://resend.com/help) if you have any questions.*

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `contact.created`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `contact.created` event contains the following
parameters:

**object parameters**

**id** `string` *required*

Unique identifier for the contact

**audience\_id** `string`

Unique identifier for the audience this contact belongs to

**segment\_ids** `array`

Array of segment IDs the contact belongs to

**created\_at** `string` *required*

ISO 8601 timestamp when the contact was created

**updated\_at** `string` *required*

ISO 8601 timestamp when the contact was last updated

**email** `string` *required*

Contact's email address

**first\_name** `string | null`

Contact's first name. May be absent from the payload

**last\_name** `string | null`

Contact's last name. May be absent from the payload

**unsubscribed** `boolean` *required*

Whether the contact has unsubscribed from all Broadcasts and Automation emails
sent from your team

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "contact.created",
  "created_at": "2026-11-17T19:32:22.980Z",
  "data": {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    "segment_ids": ["78261eea-8f8b-4381-83c6-79fa7120f1cf"],
    "created_at": "2026-11-17T19:32:22.980Z",
    "updated_at": "2026-11-17T19:32:22.980Z",
    "email": "steve.wozniak@gmail.com",
    "first_name": null,
    "last_name": null,
    "unsubscribed": false
  }
}
```


# contact.deleted
Source: https://resend.com/docs/webhooks/contacts/deleted

Received when a contact is deleted.

Event triggered whenever a **contact was successfully deleted**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `contact.deleted`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `contact.deleted` event contains the following
parameters:

**object parameters**

**id** `string` *required*

Unique identifier for the contact

**audience\_id** `string`

Unique identifier for the audience this contact belongs to

**segment\_ids** `array`

Array of segment IDs the contact belongs to

**created\_at** `string` *required*

ISO 8601 timestamp when the contact was created

**updated\_at** `string` *required*

ISO 8601 timestamp when the contact was last updated

**email** `string` *required*

Contact's email address

**first\_name** `string | null`

Contact's first name. May be absent from the payload

**last\_name** `string | null`

Contact's last name. May be absent from the payload

**unsubscribed** `boolean` *required*

Whether the contact has unsubscribed from all Broadcasts and Automation emails
sent from your team

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "contact.deleted",
  "created_at": "2026-11-17T19:32:22.980Z",
  "data": {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    "segment_ids": ["78261eea-8f8b-4381-83c6-79fa7120f1cf"],
    "created_at": "2026-11-10T15:11:59.110Z",
    "updated_at": "2026-11-17T19:32:22.980Z",
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
    "unsubscribed": false
  }
}
```


# contact.topics.updated
Source: https://resend.com/docs/webhooks/contacts/topics-updated

Received when a contact's topic subscriptions change.

Event triggered whenever a **contact's topic subscriptions change**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `contact.topics.updated`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `contact.topics.updated` event contains the following
parameters:

**object parameters**

**email** `string`

Contact's email address

**topics** `array`

Topics changed in this update, each with its new subscription

**topic object**

**id** `string`

Unique identifier for the topic

**subscription** `opt_in | opt_out`

The contact's new subscription to the topic

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "contact.topics.updated",
  "created_at": "2026-02-12T10:00:00.000Z",
  "data": {
    "email": "steve.wozniak@gmail.com",
    "topics": [
      {
        "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
        "subscription": "opt_in"
      },
      {
        "id": "07d84122-7224-4881-9c31-1c048e204602",
        "subscription": "opt_out"
      }
    ]
  }
}
```


# contact.updated
Source: https://resend.com/docs/webhooks/contacts/updated

Received when a contact is updated.

Event triggered whenever a **contact was successfully updated**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `contact.updated`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `contact.updated` event contains the following
parameters:

**object parameters**

**id** `string` *required*

Unique identifier for the contact

**audience\_id** `string`

Unique identifier for the audience this contact belongs to

**segment\_ids** `array`

Array of segment IDs the contact belongs to

**created\_at** `string` *required*

ISO 8601 timestamp when the contact was created

**updated\_at** `string` *required*

ISO 8601 timestamp when the contact was last updated

**email** `string` *required*

Contact's email address

**first\_name** `string | null`

Contact's first name. May be absent from the payload

**last\_name** `string | null`

Contact's last name. May be absent from the payload

**unsubscribed** `boolean` *required*

Whether the contact has unsubscribed from all Broadcasts and Automation emails
sent from your team

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "contact.updated",
  "created_at": "2026-10-11T23:47:56.678Z",
  "data": {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    "segment_ids": ["78261eea-8f8b-4381-83c6-79fa7120f1cf"],
    "created_at": "2026-10-10T15:11:54.110Z",
    "updated_at": "2026-10-11T23:47:56.678Z",
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
    "unsubscribed": false
  }
}
```


# Create a Webhook
Source: https://resend.com/docs/webhooks/create-webhook

Learn how to add a webhook to notify your application about events from Resend.

## How to receive webhooks

To receive real-time events in your app via webhooks, follow these steps.

Prefer video? Watch the tutorial below.

[YouTube video player](https://www.youtube.com/embed/3Yq6hivNMZg)

**1. Create a dev endpoint to receive requests**

In your local application, create a new route that can accept POST requests.

For example, you can add an API route:

```js pages/api/webhooks.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
export default (req, res) => {
  if (req.method === 'POST') {
    const event = req.body;
    console.log(event);
    res.status(200).json({});
  }
};
```

On receiving an event, respond with an `HTTP 200 OK` to signal to Resend that the event was successfully delivered.

> [!TIP]
>
> For development, you can create a tunnel to your localhost server using a tool like
> [ngrok](https://ngrok.com/download) or [VS Code Port Forwarding](https://code.visualstudio.com/docs/debugtest/port-forwarding). These tools serve your local dev environment at a public URL you can use to test your local webhook endpoint.
>
> Example: `https://example123.ngrok.io/api/webhook`

> [!TIP]
>
> The [Resend CLI](/docs/cli) has a built-in `webhooks listen` command that handles
> local webhook development. It starts a server, registers a temporary webhook,
> and streams events to your terminal. See the [CLI reference](/docs/cli#webhooks)
> for setup instructions.

**2. Add a webhook in Resend**

Navigate to the [Webhooks page](https://resend.com/webhooks), then select **Add Webhook**.

1. Add your publicly accessible HTTPS URL
2. Select all events you want to observe

![Add Webhook](https://mintcdn.com/resend/Yj8a87v7gte2iMlD/images/dashboard-webhooks-add.jpg?fit=max\&auto=format\&n=Yj8a87v7gte2iMlD\&q=85\&s=222f2ef78900140d2d18bcaef4a925af)

> [!NOTE]
>
> Resend also supports managing webhooks via the API or the SDKs. View the [API reference](/docs/api-reference/webhooks/create-webhook) for more details.

**3. Test your local endpoint**

To ensure your endpoint is successfully receiving events, perform an event you are tracking with your webhook, like sending an email, creating a contact, or creating a domain.

The webhook will send a JSON payload to your endpoint with the event details. For example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.bounced",
  "created_at": "2026-11-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-11-22T23:41:11.894719+00:00",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "message_id": "<111-222-333@email.example.com>",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "bounce": {
      "message": "The recipient's email address is on the suppression list because it has a recent history of producing hard bounces.",
      "subType": "Suppressed",
      "type": "Permanent"
    },
    "tags": {
      "category": "confirm_email"
    }
  }
}
```

You can also see the webhook details in the dashboard.

![Webhook Events List](https://mintcdn.com/resend/Yj8a87v7gte2iMlD/images/dashboard-webhook-events-list.png?fit=max\&auto=format\&n=Yj8a87v7gte2iMlD\&q=85\&s=c593c9b5e09e91d2d9eed3106aa0a81b)

> [!NOTE]
>
> View all possible [event types and their webhook payload
> responses](/docs/webhooks/event-types).

**4. Update and deploy your production endpoint**

Once you successfully receive events, update your endpoint to process the events.

For example, update your API route:

```js pages/api/webhooks.ts theme={"theme":{"light":"github-light","dark":"vesper"}}
export default (req, res) => {
  if (req.method === 'POST') {
    const event = req.body;
    if (event.type === 'email.bounced') {
      //
    }
    res.status(200).json({});
  }
};
```

After you're done testing, deploy your webhook endpoint to production.

**5. Register your production webhook endpoint**

Once your webhook endpoint is deployed to production, you can register it in the Resend dashboard.

## FAQ

> [accordion] What is the retry schedule?
>
> If Resend does not receive a 200 response from a webhook server, we will retry the webhooks.
>
> Each message is attempted based on the following schedule, where each period is started following the failure of the preceding attempt:
>
> * Immediately
> * 5 seconds
> * 5 minutes
> * 30 minutes
> * 2 hours
> * 5 hours
> * 10 hours
> * 10 hours (in addition to the previous)
>
> You can see when a message will be retried next in the webhook message details in the dashboard.

> [accordion] What IPs do webhooks POST from?
>
> If your server requires an allowlist, our webhooks come from the following IP addresses:
>
> * `44.228.126.217`
> * `50.112.21.217`
> * `52.24.126.164`
> * `54.148.139.208`
> * `2600:1f24:64:8000::/52`

> [accordion] What are the delivery guarantees?
>
> Resend webhooks provide **at-least-once** delivery. Every event will be delivered to your endpoint at least once, but may be delivered more than once in rare cases (such as network timeouts where your server processed the event but the acknowledgement was lost).
>
> To handle duplicates, use the `svix-id` header included with every webhook request. This is a unique identifier for each event delivery. Store processed `svix-id` values and skip any duplicates.

> [accordion] Do events arrive in order?
>
> Events are sent as they occur, but **delivery order is not guaranteed**. Network conditions, retries, and processing delays can cause events to arrive out of order. For example, an `email.opened` event could arrive before the `email.delivered` event for the same email.
>
> If ordering matters for your application, use the `created_at` timestamp in the event payload to sort events after receipt.

> [accordion] Can I replay webhook events manually?
>
> Yes. You can replay webhook events manually from the dashboard.
>
> You can replay both `failed` and `succeeded` events. Replaying successful events is useful when you need to:
>
> * Backfill your system after an outage on your endpoint.
> * Reprocess events with updated handler code.
> * Send the event to a different endpoint for testing.
>
> To replay a webhook event, click to see your webhook details
> and then click the link to the event you want to replay.
>
> On that page, you will see both the payload for the event
> and a button to replay the webhook event and get it sent to
> the configured webhook endpoint.
>
> For more details, see [Retries and Replays](/docs/webhooks/retries-and-replays).

## API Reference

For complete API documentation, see the [Webhooks API reference](/docs/api-reference/webhooks/create-webhook).

## Examples

> [card] [Next.js (TypeScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/inbound)
>
> See the full source code.

> [card] [Next.js (JavaScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/inbound)
>
> See the full source code.

> [card] [PHP](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/inbound)
>
> See the full source code.

> [card] [Laravel](https://github.com/resend/resend-examples/tree/main/laravel-resend-examples)
>
> See the full source code.

> [card] [Python](https://github.com/resend/resend-examples/tree/main/python-resend-examples/examples)
>
> See the full source code.

> [card] [Ruby](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples)
>
> See the full source code.


# domain.created
Source: https://resend.com/docs/webhooks/domains/created

Received when a domain is created.

Event triggered when a **domain was successfully created**.

> [!NOTE]
>
> If you're having issues verifying your domain, [review our guide on a domain
> not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying) for
> troubleshooting steps.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `domain.created`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `domain.created` event contains the following
parameters:

**object parameters**

**id** `string`

Unique identifier for the domain

**name** `string`

Domain name (e.g., `example.com`)

**status** `verified | partially_verified | partially_failed | failed | pending | not_started`

Current verification status of the domain:

* `verified`: The domain is verified and can be used to send or receive emails.
* `partially_verified`: One capability (send or receive) is verified while the other is still pending verification.
* `partially_failed`: The domain is verified but one of the features (send or receive) is not verified.
* `pending`: The domain is pending verification and cannot be used to send or receive emails.
* `not_started`: Verification has not started yet, so the domain cannot be used to send or receive emails.
* `failed`: The domain failed verification.

> [!NOTE]
>
> The `data.status` field represents an aggregated status of the domain. For
> domains that can both [send](/docs/dashboard/emails/introduction) and
> [receive](/docs/dashboard/receiving/introduction) emails, the status may be
> `partially_verified` (one capability verified, the other pending) or
> `partially_failed` (one capability verified, the other failed).

**created\_at** `string`

ISO 8601 timestamp when the domain was created

**region** `us-east-1 | eu-west-1 | sa-east-1 | ap-northeast-1`

AWS region where the domain is configured.

**capabilities** `object`

Domain capabilities for sending and receiving emails.

**properties**

**sending** `enabled | disabled`

Whether the domain can be used to send emails.

**receiving** `enabled | disabled`

Whether the domain can be used to receive emails.

**records** `array`

Array of DNS record objects required for domain verification

**record object**

**record** `SPF | DKIM | Receiving MX | Tracking | TrackingCAA`

Record type purpose. Learn more about [domain verification records](/docs/dashboard/domains/introduction).

**name** `string`

DNS record name/subdomain

**type** `MX | TXT | CNAME | CAA`

DNS record type

**value** `string`

DNS record value to be set

**ttl** `string`

Time to live for the DNS record

**status** `string`

Verification status of this specific record

**priority** `number`

Priority value for MX records (optional)

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "domain.created",
  "created_at": "2026-11-17T19:32:22.980Z",
  "data": {
    "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
    "name": "example.com",
    "status": "not_started",
    "created_at": "2026-04-26T20:21:26.347Z",
    "region": "us-east-1",
    "capabilities": {
      "sending": "enabled",
      "receiving": "disabled"
    },
    "records": [
      {
        "record": "SPF",
        "name": "send",
        "type": "MX",
        "ttl": "Auto",
        "status": "not_started",
        "value": "feedback-smtp.us-east-1.amazonses.com",
        "priority": 10
      },
      {
        "record": "SPF",
        "name": "send",
        "value": "\"v=spf1 include:amazonses.com ~all\"",
        "type": "TXT",
        "ttl": "Auto",
        "status": "not_started"
      },
      {
        "record": "DKIM",
        "name": "resend._domainkey",
        "value": "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsc4Lh8xilsngyKEgN2S84+21gn+x6SEXtjWvPiAAmnmggr5FWG42WnqczpzQ/mNblqHz4CDwUum6LtY6SdoOlDmrhvp5khA3cd661W9FlK3yp7+jVACQElS7d9O6jv8VsBbVg4COess3gyLE5RyxqF1vYsrEXqyM8TBz1n5AGkQIDAQA2",
        "type": "TXT",
        "status": "not_started",
        "ttl": "Auto"
      }
    ]
  }
}
```


# domain.deleted
Source: https://resend.com/docs/webhooks/domains/deleted

Received when a domain is deleted.

Event triggered when a **domain was successfully deleted**.

> [!NOTE]
>
> If you're having issues verifying your domain, [review our guide on a domain
> not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying) for
> troubleshooting steps.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `domain.deleted`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `domain.deleted` event contains the following
parameters:

**object parameters**

**id** `string`

Unique identifier for the domain

**name** `string`

Domain name (e.g., `example.com`)

**status** `verified | partially_verified | partially_failed | failed | pending | not_started`

Current verification status of the domain:

* `verified`: The domain is verified and can be used to send or receive emails.
* `partially_verified`: One capability (send or receive) is verified while the other is still pending verification.
* `partially_failed`: The domain is verified but one of the features (send or receive) is not verified.
* `pending`: The domain is pending verification and cannot be used to send or receive emails.
* `not_started`: Verification has not started yet, so the domain cannot be used to send or receive emails.
* `failed`: The domain failed verification.

> [!NOTE]
>
> The `data.status` field represents an aggregated status of the domain. For
> domains that can both [send](/docs/dashboard/emails/introduction) and
> [receive](/docs/dashboard/receiving/introduction) emails, the status may be
> `partially_verified` (one capability verified, the other pending) or
> `partially_failed` (one capability verified, the other failed).

**created\_at** `string`

ISO 8601 timestamp when the domain was created

**region** `us-east-1 | eu-west-1 | sa-east-1 | ap-northeast-1`

AWS region where the domain is configured.

**capabilities** `object`

Domain capabilities for sending and receiving emails.

**properties**

**sending** `enabled | disabled`

Whether the domain can be used to send emails.

**receiving** `enabled | disabled`

Whether the domain can be used to receive emails.

**records** `array`

Array of DNS record objects required for domain verification

**record object**

**record** `SPF | DKIM | Receiving MX | Tracking | TrackingCAA`

Record type purpose. Learn more about [domain verification records](/docs/dashboard/domains/introduction).

**name** `string`

DNS record name/subdomain

**type** `MX | TXT | CNAME | CAA`

DNS record type

**value** `string`

DNS record value to be set

**ttl** `string`

Time to live for the DNS record

**status** `string`

Verification status of this specific record

**priority** `number`

Priority value for MX records (optional)

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "domain.deleted",
  "created_at": "2026-11-17T19:32:22.980Z",
  "data": {
    "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
    "name": "example.com",
    "status": "not_started",
    "created_at": "2026-04-26T20:21:26.347Z",
    "region": "us-east-1",
    "capabilities": {
      "sending": "enabled",
      "receiving": "disabled"
    },
    "records": [
      {
        "record": "SPF",
        "name": "send",
        "type": "MX",
        "ttl": "Auto",
        "status": "not_started",
        "value": "feedback-smtp.us-east-1.amazonses.com",
        "priority": 10
      },
      {
        "record": "SPF",
        "name": "send",
        "value": "\"v=spf1 include:amazonses.com ~all\"",
        "type": "TXT",
        "ttl": "Auto",
        "status": "not_started"
      },
      {
        "record": "DKIM",
        "name": "resend._domainkey",
        "value": "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsc4Lh8xilsngyKEgN2S84+21gn+x6SEXtjWvPiAAmnmggr5FWG42WnqczpzQ/mNblqHz4CDwUum6LtY6SdoOlDmrhvp5khA3cd661W9FlK3yp7+jVACQElS7d9O6jv8VsBbVg4COess3gyLE5RyxqF1vYsrEXqyM8TBz1n5AGkQIDAQA2",
        "type": "TXT",
        "status": "not_started",
        "ttl": "Auto"
      }
    ]
  }
}
```


# domain.updated
Source: https://resend.com/docs/webhooks/domains/updated

Received when a domain is updated.

Event triggered when a **domain was successfully updated**.

> [!NOTE]
>
> If you're having issues verifying your domain, [review our guide on a domain
> not verifying](/docs/knowledge-base/what-if-my-domain-is-not-verifying) for
> troubleshooting steps.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `domain.updated`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `domain.updated` event contains the following
parameters:

**object parameters**

**id** `string`

Unique identifier for the domain

**name** `string`

Domain name (e.g., `example.com`)

**status** `verified | partially_verified | partially_failed | failed | pending | not_started`

Current verification status of the domain:

* `verified`: The domain is verified and can be used to send or receive emails.
* `partially_verified`: One capability (send or receive) is verified while the other is still pending verification.
* `partially_failed`: The domain is verified but one of the features (send or receive) is not verified.
* `pending`: The domain is pending verification and cannot be used to send or receive emails.
* `not_started`: Verification has not started yet, so the domain cannot be used to send or receive emails.
* `failed`: The domain failed verification.

> [!NOTE]
>
> The `data.status` field represents an aggregated status of the domain. For
> domains that can both [send](/docs/dashboard/emails/introduction) and
> [receive](/docs/dashboard/receiving/introduction) emails, the status may be
> `partially_verified` (one capability verified, the other pending) or
> `partially_failed` (one capability verified, the other failed).

**created\_at** `string`

ISO 8601 timestamp when the domain was created

**region** `us-east-1 | eu-west-1 | sa-east-1 | ap-northeast-1`

AWS region where the domain is configured.

**capabilities** `object`

Domain capabilities for sending and receiving emails.

**properties**

**sending** `enabled | disabled`

Whether the domain can be used to send emails.

**receiving** `enabled | disabled`

Whether the domain can be used to receive emails.

**records** `array`

Array of DNS record objects required for domain verification

**record object**

**record** `SPF | DKIM | Receiving MX | Tracking | TrackingCAA`

Record type purpose. Learn more about [domain verification records](/docs/dashboard/domains/introduction).

**name** `string`

DNS record name/subdomain

**type** `MX | TXT | CNAME | CAA`

DNS record type

**value** `string`

DNS record value to be set

**ttl** `string`

Time to live for the DNS record

**status** `string`

Verification status of this specific record

**priority** `number`

Priority value for MX records (optional)

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "domain.updated",
  "created_at": "2026-11-17T19:32:22.980Z",
  "data": {
    "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
    "name": "example.com",
    "status": "not_started",
    "created_at": "2026-04-26T20:21:26.347Z",
    "region": "us-east-1",
    "capabilities": {
      "sending": "enabled",
      "receiving": "enabled"
    },
    "records": [
      {
        "record": "SPF",
        "name": "send",
        "type": "MX",
        "ttl": "Auto",
        "status": "not_started",
        "value": "feedback-smtp.us-east-1.amazonses.com",
        "priority": 10
      },
      {
        "record": "SPF",
        "name": "send",
        "value": "\"v=spf1 include:amazonses.com ~all\"",
        "type": "TXT",
        "ttl": "Auto",
        "status": "not_started"
      },
      {
        "record": "DKIM",
        "name": "resend._domainkey",
        "value": "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsc4Lh8xilsngyKEgN2S84+21gn+x6SEXtjWvPiAAmnmggr5FWG42WnqczpzQ/mNblqHz4CDwUum6LtY6SdoOlDmrhvp5khA3cd661W9FlK3yp7+jVACQElS7d9O6jv8VsBbVg4COess3gyLE5RyxqF1vYsrEXqyM8TBz1n5AGkQIDAQA2",
        "type": "TXT",
        "status": "not_started",
        "ttl": "Auto"
      },
      {
        "name": "inbound.yourdomain.tld",
        "priority": 10,
        "record": "Receiving MX",
        "status": "pending",
        "ttl": "Auto",
        "type": "MX",
        "value": "inbound-smtp.us-east-1.amazonaws.com"
      }
    ]
  }
}
```


# email.bounced
Source: https://resend.com/docs/webhooks/emails/bounced

Received when an email bounces.

Event triggered whenever the recipient's mail server **permanently rejected the email**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.bounced`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.bounced` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

**bounce** `object`

Bounce details from the receiving server

**bounce object**

**diagnosticCode** `array`

Array of SMTP diagnostic responses from the receiving server, including the status code and reason for the bounce (e.g., `smtp; 550 5.5.0 Requested action not taken: mailbox unavailable`)

**message** `string`

Detailed bounce message from the receiving server

**subType** `string`

Bounce sub-type (e.g., `Suppressed`, `MessageRejected`)

**type** `string`

Bounce type (e.g., `Permanent`, `Temporary`)

> [!NOTE]
>
> Learn more about [bounce types and subtypes](/docs/dashboard/emails/email-bounces).

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.bounced",
  "created_at": "2026-11-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-11-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "message_id": "<111-222-333@email.example.com>",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "bounce": {
      "message": "The recipient's email address is on the suppression list because it has a recent history of producing hard bounces.",
      "subType": "Suppressed",
      "type": "Permanent"
    },
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# email.clicked
Source: https://resend.com/docs/webhooks/emails/clicked

Received when an email link is clicked.

Event triggered whenever the **recipient clicks on an email link**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.clicked`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.clicked` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

**click** `object`

Click tracking details

**click object**

**ipAddress** `string`

IP address of the user who clicked the link

**link** `string`

The URL that was clicked

**timestamp** `string`

ISO 8601 timestamp when the click occurred

**userAgent** `string`

User agent string of the browser that clicked the link

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.clicked",
  "created_at": "2026-11-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-11-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "message_id": "<111-222-333@email.example.com>",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "click": {
      "ipAddress": "122.115.53.11",
      "link": "https://resend.com",
      "timestamp": "2026-11-24T05:00:57.163Z",
      "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15"
    },
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# email.complained
Source: https://resend.com/docs/webhooks/emails/complained

Received when an email is marked as spam.

Event triggered whenever the email was successfully **delivered, but the recipient marked it as spam**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.complained`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.complained` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.complained",
  "created_at": "2026-02-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-02-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "message_id": "<111-222-333@email.example.com>",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# email.delivered
Source: https://resend.com/docs/webhooks/emails/delivered

Received when an email is delivered.

Event triggered whenever Resend **successfully delivered the email** to the recipient's mail server.

> [!NOTE]
>
> Learn more about what to do [when an email is delivered, but the recipient
> does not receive
> it](/docs/knowledge-base/what-if-an-email-says-delivered-but-the-recipient-has-not-received-it).

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.delivered`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.delivered` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.delivered",
  "created_at": "2026-02-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-02-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "message_id": "<111-222-333@email.example.com>",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# email.delivery_delayed
Source: https://resend.com/docs/webhooks/emails/delivery-delayed

Received when an email delivery is delayed.

Event triggered whenever the **email couldn't be delivered due to a temporary issue**.

Delivery delays can occur, for example, when the recipient's inbox is full, or when the receiving email server experiences a transient issue.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.delivery_delayed`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.delivery_delayed` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.delivery_delayed",
  "created_at": "2026-02-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-02-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "message_id": "<111-222-333@email.example.com>",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# email.failed
Source: https://resend.com/docs/webhooks/emails/failed

Received when an email fails to send.

Event triggered whenever the **email failed to send due to an error**.

This event is triggered when there are issues such as invalid recipients, API key problems, domain verification issues, email quota limits, or other sending failures.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.failed`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.failed` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

**failed** `object`

Failure details

**failed object**

**reason** `string`

Reason for the email failure (e.g., `reached_daily_quota`)

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.failed",
  "created_at": "2026-11-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-11-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "failed": {
      "reason": "reached_daily_quota"
    },
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# email.opened
Source: https://resend.com/docs/webhooks/emails/opened

Received when an email is opened.

Event triggered whenever the **recipient opened the email**.

> [!NOTE]
>
> Open rates are not always accurate. Learn more about [why open rates may not
> be accurate](/docs/knowledge-base/why-are-my-open-rates-not-accurate).

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.opened`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.opened` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.opened",
  "created_at": "2026-02-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-02-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "message_id": "<111-222-333@email.example.com>",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# email.received
Source: https://resend.com/docs/webhooks/emails/received

Received when an inbound email is received.

Event triggered whenever Resend **successfully receives an email**.

> [!NOTE]
>
> Webhooks do not include the email body, headers, or attachments, only their
> metadata. You must call the [Received emails
> API](/docs/api-reference/emails/retrieve-received-email) or the [Attachments
> API](/docs/api-reference/emails/list-received-email-attachments) to retrieve them.
> This design choice supports large attachments in serverless environments that
> have limited request body sizes.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.received`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.received` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

**received\_for** `array`

The recipient addresses the email was forwarded for, taken from the `for` clause of the message's `Received` headers.

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.received",
  "created_at": "2026-02-22T23:41:12.126Z",
  "data": {
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "created_at": "2026-02-22T23:41:11.894Z",
    "from": "onboarding@resend.dev",
    "to": ["delivered@resend.dev"],
    "bcc": [],
    "cc": [],
    "received_for": ["forwarded@example.com"],
    "message_id": "<111-222-333@email.example.com>",
    "subject": "Sending this example",
    "attachments": [
      {
        "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
        "filename": "avatar.png",
        "content_type": "image/png",
        "content_disposition": "inline",
        "content_id": "img001"
      }
    ]
  }
}
```


# email.scheduled
Source: https://resend.com/docs/webhooks/emails/scheduled

Received when an email is scheduled to be sent.

Event triggered whenever the **email is scheduled to be sent**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.scheduled`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.scheduled` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.scheduled",
  "created_at": "2026-02-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-02-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# email.sent
Source: https://resend.com/docs/webhooks/emails/sent

Received when an email is sent.

Event triggered whenever the **API request was successful**. Resend will attempt to deliver the message to the recipient's mail server.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.sent`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.sent` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.sent",
  "created_at": "2026-02-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-02-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "message_id": "<111-222-333@email.example.com>",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# email.suppressed
Source: https://resend.com/docs/webhooks/emails/suppressed

Received when an email is suppressed.

Event triggered whenever the **email is suppressed** by Resend.

> [!NOTE]
>
> Learn more about [suppressed
> emails](/docs/knowledge-base/why-are-my-emails-landing-on-the-suppression-list).

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `email.suppressed`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `email.suppressed` event contains the following
parameters:

**object parameters**

**broadcast\_id** `string`

Unique identifier for the broadcast campaign (if applicable)

**created\_at** `string`

ISO 8601 timestamp when the email was created

**email\_id** `string`

Unique identifier for the specific email

**message\_id** `string`

RFC Message-ID header value for the email. Not included on `email.scheduled`,
`email.failed` and `email.suppressed` events, because the email has not been
sent when they fire

**from** `string`

Sender's email address. For sent events, this matches the value passed at send time and may include a display name (e.g., `Name <email@domain.com>`). For received events, this is the bare email address only; the display name from the original `From:` header is preserved in `headers.from` on the [retrieve endpoint](/docs/api-reference/emails/retrieve-received-email).

**to** `array`

Array of impacted recipient email addresses

**subject** `string`

Email subject line

**template\_id** `string`

Unique identifier for the template used (if applicable)

**tags** `Record\<string, string\>`

Object of tag key-value pairs associated with the email.

Example:

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "category": "welcome",
  "user_id": "1234567890"
}
```

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "email.suppressed",
  "created_at": "2026-11-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2026-11-22T23:41:11.894Z",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "suppressed": {
      "message": "Resend has suppressed sending to this address because it is on the account-level suppression list. This does not count toward your bounce rate metric",
      "type": "OnAccountSuppressionList"
    },
    "tags": {
      "category": "confirm_email"
    }
  }
}
```


# Event Types
Source: https://resend.com/docs/webhooks/event-types

List of supported event types and their payload.

## Email Events

&#x20;

[`email.bounced`](/docs/webhooks/emails/bounced)

Occurs whenever the recipient's mail server **permanently rejected the
email**.

&#x20;

[`email.clicked`](/docs/webhooks/emails/clicked)

Occurs whenever the **recipient clicks on an email link**.

&#x20;

[`email.complained`](/docs/webhooks/emails/complained)

Occurs whenever the email was successfully **delivered, but the recipient
marked it as spam**.

&#x20;

[`email.delivered`](/docs/webhooks/emails/delivered)

Occurs whenever Resend **successfully delivered the email** to the
recipient's mail server.

&#x20;

[`email.delivery_delayed`](/docs/webhooks/emails/delivery-delayed)

Occurs whenever the **email couldn't be delivered due to a temporary
issue**. Delivery delays can occur, for example, when the recipient's
inbox is full, or when the receiving email server experiences a transient
issue.

&#x20;

[`email.failed`](/docs/webhooks/emails/failed)

Occurs whenever the **email failed to send due to an error**. This event
is triggered when there are issues such as invalid recipients, API key
problems, domain verification issues, email quota limits, or other sending
failures.

&#x20;

[`email.opened`](/docs/webhooks/emails/opened)

Occurs whenever the **recipient opened the email**.

&#x20;

[`email.received`](/docs/webhooks/emails/received)

Occurs whenever Resend **successfully receives an email**.

&#x20;

[`email.scheduled`](/docs/webhooks/emails/scheduled)

Occurs whenever the **email is scheduled to be sent**.

&#x20;

[`email.sent`](/docs/webhooks/emails/sent)

Occurs whenever the **API request was successful**. Resend will attempt to
deliver the message to the recipient's mail server.

&#x20;

[`email.suppressed`](/docs/webhooks/emails/suppressed)

Occurs whenever the **email is suppressed** by Resend.

## Domain Events

&#x20;

[`domain.created`](/docs/webhooks/domains/created)

Occurs when a **domain was successfully created**.

&#x20;

[`domain.updated`](/docs/webhooks/domains/updated)

Occurs when a **domain was successfully updated**.

&#x20;

[`domain.deleted`](/docs/webhooks/domains/deleted)

Occurs when a **domain was successfully deleted**.

## Contact Events

&#x20;

[`contact.created`](/docs/webhooks/contacts/created)

Occurs whenever a **contact was successfully created**.

*Note: When importing multiple contacts using CSV, these events won't be
triggered. [Contact support](https://resend.com/help) if you have any
questions.*

&#x20;

[`contact.updated`](/docs/webhooks/contacts/updated)

Occurs whenever a **contact was successfully updated**.

&#x20;

[`contact.deleted`](/docs/webhooks/contacts/deleted)

Occurs whenever a **contact was successfully deleted**.

&#x20;

[`contact.topics.updated`](/docs/webhooks/contacts/topics-updated)

Occurs whenever a **contact's topic subscriptions change**.

## Suppression Events

&#x20;

[`suppression.added`](/docs/webhooks/suppressions/added)

Occurs whenever an **email address is added to your suppression list**,
automatically after a hard bounce or spam complaint, or manually through
the dashboard or API.

&#x20;

[`suppression.removed`](/docs/webhooks/suppressions/removed)

Occurs whenever an **email address is removed from your suppression
list**.

## Topic Events

&#x20;

[`topic.created`](/docs/webhooks/topics/created)

Occurs whenever a **topic is created**.

&#x20;

[`topic.updated`](/docs/webhooks/topics/updated)

Occurs whenever a **topic is updated**.

&#x20;

[`topic.deleted`](/docs/webhooks/topics/deleted)

Occurs whenever a **topic is deleted**.

## Inbox Events

Every inbox event's `data` has `source` and `inbox_id`, plus the IDs and objects that apply to the event. Keys that don't apply are left out, not sent as `null`.

The `thread`, `email`, `draft` and `inbox` objects are loaded when the webhook is sent, not when the change happened, so two quick changes can both show the second state. `email` and `draft` leave out `html` and `text`; fetch the body from the API. Retries keep the same `svix-id` header, so dedupe on it.

&#x20;

[`inbox.created`](/docs/webhooks/inboxes/created)

Occurs whenever an **inbox is created**.

&#x20;

[`inbox.updated`](/docs/webhooks/inboxes/updated)

Occurs whenever an **inbox's settings change**.

&#x20;

[`inbox.deleted`](/docs/webhooks/inboxes/deleted)

Occurs whenever an **inbox is deleted**.

&#x20;

[`inbox.thread.created`](/docs/webhooks/inboxes/thread-created)

Occurs whenever the **first email of a thread** lands in the inbox,
inbound or outbound.

&#x20;

[`inbox.thread.folder.updated`](/docs/webhooks/inboxes/thread-folder-updated)

Occurs whenever a **thread moves between folders**.

&#x20;

[`inbox.thread.assigned`](/docs/webhooks/inboxes/thread-assigned)

Occurs whenever a **thread is assigned or reassigned**.

&#x20;

[`inbox.thread.unassigned`](/docs/webhooks/inboxes/thread-unassigned)

Occurs whenever a **thread is unassigned**.

&#x20;

[`inbox.thread.labels.updated`](/docs/webhooks/inboxes/thread-labels-updated)

Occurs whenever a **label is applied to or removed from a thread**.

&#x20;

[`inbox.email.received`](/docs/webhooks/inboxes/email-received)

Occurs whenever an **inbound email is added to a thread**.

&#x20;

[`inbox.email.sent`](/docs/webhooks/inboxes/email-sent)

Occurs whenever an **outbound email is accepted for delivery** and added
to a thread.

&#x20;

[`inbox.draft.created`](/docs/webhooks/inboxes/draft-created)

Occurs whenever a **draft is created**, standalone or reply.

&#x20;

[`inbox.draft.updated`](/docs/webhooks/inboxes/draft-updated)

Occurs whenever a **draft is edited**.

&#x20;

[`inbox.draft.sent`](/docs/webhooks/inboxes/draft-sent)

Occurs whenever a **draft is sent**.

&#x20;

[`inbox.draft.deleted`](/docs/webhooks/inboxes/draft-deleted)

Occurs whenever a **draft is discarded**.


# How to Store Webhooks Data
Source: https://resend.com/docs/webhooks/how-to-store-webhooks-data

Storing your email event data matters. Learn how to set up your own data storage.

When you send emails with Resend, you can receive real-time notifications for each message:

* Was it delivered?
* Did the recipient open it?
* Did they click a link?
* Did it bounce?

These events contain valuable data, however, by default webhooks are ephemeral. To make the data persistent, you can store the data in your own datasource.

This guide explains [why storing your webhook data matters](#why-store-webhook-data) and [how to get started](#how-to-store-webhook-data).

## Why Store Webhook Data

Storing your own data offers several benefits.

### Meet Compliance Requirements

Many industries have regulations around data retention and audit trails:

* **GDPR** - You may need to demonstrate what communications were sent to users and when
* **SOC 2** - Audit requirements may include email delivery verification
* **Financial regulations** - Transaction-related emails may need to be retained for years

Storing your own webhook data gives you full control over retention periods and access controls.

### Enable Long-term Retention

Resend retains email data for 30 days across all plans (with flexible retention for Enterprise). If you need access to historical email data beyond that window, storing events in your own database ensures you never lose important information.

### Power Automated Workflows

With webhook data in your database, you can build powerful automations:

* Automatically suppress bounced addresses from future sends
* Trigger follow-up emails based on open/click behavior
* Alert your team when delivery issues spike
* Re-engage users who haven't opened recent emails

## How to Store Webhook Data

While you can always [build your own webhook handler](/docs/webhooks/introduction), it requires development resources.

You can get started quickly with the [Resend Webhook Ingester](/docs/webhooks/ingester). It's an open-source, ready-to-deploy solution that handles all the complexity for you:

* **One-click deployment** to Vercel, Railway, or Render
* **Signature verification** built-in using Svix
* **Idempotent storage** that handles duplicate deliveries
* **8 database connectors** including PostgreSQL, MySQL, MongoDB, and data warehouses

> [card] [Webhook Ingester](/docs/webhooks/ingester)
>
> Deploy a production-ready webhook storage solution in minutes

## Data Storage Considerations

Whether using the Webhook Ingester or your own handler, you'll need to consider the following:

### Choosing a Database

The right database depends on your use case:

| Use Case | Recommended Database |
| - | - |
| Already using Postgres | [PostgreSQL](https://www.postgresql.org/) or [Supabase](https://supabase.com/) |
| Need simple setup | [Supabase](https://supabase.com/) or [Neon](https://neon.com/) |
| High-volume analytics | [ClickHouse](https://clickhouse.com/) or [BigQuery](https://cloud.google.com/bigquery) |
| Data warehouse integration | [Snowflake](https://www.snowflake.com/) or [BigQuery](https://cloud.google.com/bigquery) |
| Serverless architecture | [Neon](https://neon.com/), [PlanetScale](https://planetscale.com/), or [Supabase](https://supabase.com/) |

> [!TIP]
>
> If you're unsure, start with [Supabase](https://supabase.com/) which has a
> generous free tier.

### What Data to Store

At minimum, store these fields for each webhook event:

* **Event ID** - The unique `svix-id` for deduplication
* **Event type** - What happened (for example, delivered, bounced, or opened)
* **Timestamp** - When the event occurred
* **Email ID** - Links the event back to the original send

For deeper analytics, also consider storing:

* **Recipient addresses** - For per-user engagement tracking
* **Subject lines** - To analyze performance by content
* **Tags** - If you use tags to categorize emails
* **Bounce details** - To understand delivery issues
* **Click URLs** - To track which links perform best

> [!NOTE]
>
> The Webhook Ingester stores all available fields automatically, so you don't
> have to decide upfront what you might need later.

## Data Retention Considerations

Before storing webhook data, consider your retention requirements:

### How Long to Keep Data

* **Operational use** - 30–90 days is often sufficient for debugging and recent analytics
* **Compliance requirements** - Check your industry regulations (often 1–7 years)
* **Historical analysis** - Consider aggregating old data rather than keeping raw events

### Privacy Considerations

Webhook data may contain personal information (email addresses, IP addresses from opens/clicks). Ensure your storage approach complies with privacy regulations:

* Implement appropriate access controls
* Consider data anonymization for long-term retention
* Have a process for handling data deletion requests

### Storage Costs

High-volume senders can generate significant data. Plan for:

* Database storage costs
* Query performance as data grows
* Archival strategies for old data

> [!TIP]
>
> Most databases support partitioning by date, making it easy to drop old
> partitions when data ages out of your retention window.

## FAQ

> [accordion] How much data will I generate?
>
> Each email can generate multiple events (sent, delivered, opened, clicked).
> A rough estimate: if you send 10,000 emails/month with average engagement,
> expect 30,000-50,000 events/month. Each event is typically 1-2 KB, so about
> 50-100 MB/month of raw data.

> [accordion] Will storing webhooks slow down my application?
>
> No. Webhook processing happens asynchronously. Your email sending is not
> affected by how you handle webhooks. If you use the Webhook Ingester, it
> runs as a separate service.

> [accordion] What if I miss a webhook?
>
> Resend automatically retries failed webhook deliveries for up to 24 hours.
> If your endpoint returns a 5xx error, we'll retry. If you need to recover
> older events, check the [Resend Dashboard](https://resend.com/webhooks)
> where you can manually replay recent events.

> [accordion] Can I store webhooks in multiple databases?
>
> The Webhook Ingester supports one database per deployment. If you need to
> store in multiple databases, you can either deploy multiple instances or
> build a custom handler that writes to multiple destinations.

## Learn More

> [card] [Webhook Ingester](/docs/webhooks/ingester)
>
> Deploy a production-ready webhook storage solution

> [card] [Webhook Event Types](/docs/webhooks/event-types)
>
> See all available event types and their payloads

> [card] [Verify Webhooks](/docs/webhooks/verify-webhooks-requests)
>
> Learn about webhook signature verification

> [card] [Webhook Introduction](/docs/webhooks/introduction)
>
> Get started with webhooks in your application


# inbox.created
Source: https://resend.com/docs/webhooks/inboxes/created

Received when an inbox is created.

Event triggered whenever an **inbox is created**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.created`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.created` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**inbox** `object`

The inbox, as it is when the webhook is sent. Absent when the inbox no longer exists

**inbox object**

**object** `string`

Always `inbox`

**id** `string`

The ID of the inbox

**name** `string`

Internal name for the inbox. Recipients do not see it. Falls back to the inbox
address

**email\_address** `string`

The address of the inbox

**domain\_id** `string`

The ID of the domain the inbox belongs to

**receiving\_address** `string | null`

The address to forward mail to when forwarding is enabled. `null` otherwise

**from\_name** `string | null`

The name recipients see when mail is sent from this inbox. `null` when not set

**unread** `number`

The number of unread threads in the Inbox folder

**drafts** `number`

The number of unsent drafts

**last\_received** `string | null`

ISO 8601 timestamp of the newest received email in the Inbox folder. `null`
when the folder has no received email

**created\_at** `string`

ISO 8601 timestamp when the inbox was created

**updated\_at** `string`

ISO 8601 timestamp set when the inbox is created and updated whenever its name
or from name changes

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.created",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "api",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "inbox": {
      "object": "inbox",
      "id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "name": "Customer Support",
      "email_address": "support@example.com",
      "domain_id": "d91cd9bd-1176-453e-8fc1-35364d380206",
      "receiving_address": null,
      "from_name": "Ada from Support",
      "unread": 0,
      "drafts": 0,
      "last_received": null,
      "created_at": "2026-09-29T12:00:00.000Z",
      "updated_at": "2026-09-29T12:00:00.214Z"
    }
  }
}
```


# inbox.deleted
Source: https://resend.com/docs/webhooks/inboxes/deleted

Received when an inbox is deleted.

Event triggered whenever an **inbox is deleted**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.deleted`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.deleted` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.deleted",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "api",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1"
  }
}
```


# inbox.draft.created
Source: https://resend.com/docs/webhooks/inboxes/draft-created

Received when a draft is created.

Event triggered whenever a **draft is created**, standalone or reply.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.draft.created`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.draft.created` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread. Only on reply drafts

**draft\_id** `string`

The ID of the draft

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists. Only on reply drafts

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

**draft** `object`

The draft, as it is when the webhook is sent, without `html` or `text`. Fetch the body with [Retrieve Draft](/docs/api-reference/inboxes/get-draft). Absent when the draft no longer exists

**draft object**

**object** `string`

Always `inbox_draft`

**id** `string`

The ID of the draft

**type** `standalone | reply`

`standalone` for a new conversation, or `reply`

**to** `string[] | null`

Recipients

**cc** `string[]`

CC recipients

**bcc** `string[]`

BCC recipients

**subject** `string | null`

The subject

**thread\_id** `string | null`

The Thread ID when this draft is a reply. `null` otherwise

**reply\_to\_email\_id** `string | null`

The Email ID being replied to. `null` otherwise

**email\_id** `string | null`

The queued outbound email after send. `null` until then

**created\_at** `string`

ISO 8601 timestamp when the draft was created

**updated\_at** `string`

ISO 8601 timestamp when the draft was last saved

**attachments** `array`

The files stored on the draft

**attachment object**

**id** `string`

The ID of the attachment

**filename** `string`

The filename of the attachment

**content\_type** `string`

The MIME type of the attachment

**size** `number`

The size of the attachment in bytes

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.draft.created",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "api",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "draft_id": "9a2b7c4d-1e3f-4a5b-8c6d-0e1f2a3b4c5d",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [],
      "read": false
    },
    "draft": {
      "object": "inbox_draft",
      "id": "9a2b7c4d-1e3f-4a5b-8c6d-0e1f2a3b4c5d",
      "type": "reply",
      "to": ["steve.wozniak@gmail.com"],
      "cc": [],
      "bcc": [],
      "subject": "Re: Question about my invoice",
      "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "reply_to_email_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "email_id": null,
      "created_at": "2026-09-29T11:58:00.000Z",
      "updated_at": "2026-09-29T12:00:00.000Z",
      "attachments": []
    }
  }
}
```


# inbox.draft.deleted
Source: https://resend.com/docs/webhooks/inboxes/draft-deleted

Received when a draft is discarded.

Event triggered whenever a **draft is discarded**.

*Note: The draft is already gone, so the payload has no `draft` object.*

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.draft.deleted`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.draft.deleted` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread. Only on reply drafts

**draft\_id** `string`

The ID of the draft

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists. Only on reply drafts

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.draft.deleted",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "dashboard",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "draft_id": "9a2b7c4d-1e3f-4a5b-8c6d-0e1f2a3b4c5d",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [],
      "read": false
    }
  }
}
```


# inbox.draft.sent
Source: https://resend.com/docs/webhooks/inboxes/draft-sent

Received when a draft is sent.

Event triggered whenever a **draft is sent**.

*Note: A sent draft also triggers `inbox.email.sent`.*

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.draft.sent`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.draft.sent` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread

**email\_id** `string`

The ID of the email

**draft\_id** `string`

The ID of the draft

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

**email** `object`

The email, as it is when the webhook is sent, without `html` or `text`. Fetch the body with [Retrieve Thread Email](/docs/api-reference/inboxes/get-thread-email). Only when the email is already on the thread when the webhook is sent

**email object**

**id** `string`

The ID of the email

**direction** `inbound | outbound`

Whether the email was received by the inbox or sent from it

**from** `string`

Sender email address. Can include the display name.

**to** `string[]`

The recipients of the email

**cc** `string[]`

The CC recipients of the email

**bcc** `string[]`

The BCC recipients of the email

**reply\_to** `string[]`

The Reply-To addresses

**subject** `string | null`

The subject of the email

**message\_id** `string | null`

The Message-ID header of the email

**attachments** `array`

The attachments on the email

**attachment object**

**id** `string`

The ID of the attachment

**filename** `string | null`

The filename of the attachment

**size** `number | null`

The size of the attachment in bytes

**read** `boolean`

Whether the email has been read

**received\_at** `string`

ISO 8601 timestamp when the email arrived or was sent

**draft** `object`

The draft, as it is when the webhook is sent, without `html` or `text`. Fetch the body with [Retrieve Draft](/docs/api-reference/inboxes/get-draft). Absent when the draft no longer exists

**draft object**

**object** `string`

Always `inbox_draft`

**id** `string`

The ID of the draft

**type** `standalone | reply`

`standalone` for a new conversation, or `reply`

**to** `string[] | null`

Recipients

**cc** `string[]`

CC recipients

**bcc** `string[]`

BCC recipients

**subject** `string | null`

The subject

**thread\_id** `string | null`

The Thread ID when this draft is a reply. `null` otherwise

**reply\_to\_email\_id** `string | null`

The Email ID being replied to. `null` otherwise

**email\_id** `string | null`

The queued outbound email after send. `null` until then

**created\_at** `string`

ISO 8601 timestamp when the draft was created

**updated\_at** `string`

ISO 8601 timestamp when the draft was last saved

**attachments** `array`

The files stored on the draft

**attachment object**

**id** `string`

The ID of the attachment

**filename** `string`

The filename of the attachment

**content\_type** `string`

The MIME type of the attachment

**size** `number`

The size of the attachment in bytes

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.draft.sent",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "api",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "email_id": "81ce9b8d-1b0a-4d02-a4d9-2a91f5ab6397",
    "draft_id": "9a2b7c4d-1e3f-4a5b-8c6d-0e1f2a3b4c5d",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [],
      "read": true
    },
    "draft": {
      "object": "inbox_draft",
      "id": "9a2b7c4d-1e3f-4a5b-8c6d-0e1f2a3b4c5d",
      "type": "reply",
      "to": ["steve.wozniak@gmail.com"],
      "cc": [],
      "bcc": [],
      "subject": "Re: Question about my invoice",
      "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "reply_to_email_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "email_id": "81ce9b8d-1b0a-4d02-a4d9-2a91f5ab6397",
      "created_at": "2026-09-29T11:58:00.000Z",
      "updated_at": "2026-09-29T12:00:00.000Z",
      "attachments": []
    }
  }
}
```


# inbox.draft.updated
Source: https://resend.com/docs/webhooks/inboxes/draft-updated

Received when a draft is edited.

Event triggered whenever a **draft is edited**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.draft.updated`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.draft.updated` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread. Only on reply drafts

**draft\_id** `string`

The ID of the draft

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists. Only on reply drafts

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

**draft** `object`

The draft, as it is when the webhook is sent, without `html` or `text`. Fetch the body with [Retrieve Draft](/docs/api-reference/inboxes/get-draft). Absent when the draft no longer exists

**draft object**

**object** `string`

Always `inbox_draft`

**id** `string`

The ID of the draft

**type** `standalone | reply`

`standalone` for a new conversation, or `reply`

**to** `string[] | null`

Recipients

**cc** `string[]`

CC recipients

**bcc** `string[]`

BCC recipients

**subject** `string | null`

The subject

**thread\_id** `string | null`

The Thread ID when this draft is a reply. `null` otherwise

**reply\_to\_email\_id** `string | null`

The Email ID being replied to. `null` otherwise

**email\_id** `string | null`

The queued outbound email after send. `null` until then

**created\_at** `string`

ISO 8601 timestamp when the draft was created

**updated\_at** `string`

ISO 8601 timestamp when the draft was last saved

**attachments** `array`

The files stored on the draft

**attachment object**

**id** `string`

The ID of the attachment

**filename** `string`

The filename of the attachment

**content\_type** `string`

The MIME type of the attachment

**size** `number`

The size of the attachment in bytes

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.draft.updated",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "agent",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "draft_id": "9a2b7c4d-1e3f-4a5b-8c6d-0e1f2a3b4c5d",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [],
      "read": false
    },
    "draft": {
      "object": "inbox_draft",
      "id": "9a2b7c4d-1e3f-4a5b-8c6d-0e1f2a3b4c5d",
      "type": "reply",
      "to": ["steve.wozniak@gmail.com"],
      "cc": [],
      "bcc": [],
      "subject": "Re: Question about my invoice",
      "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "reply_to_email_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "email_id": null,
      "created_at": "2026-09-29T11:58:00.000Z",
      "updated_at": "2026-09-29T12:00:00.000Z",
      "attachments": []
    }
  }
}
```


# inbox.email.received
Source: https://resend.com/docs/webhooks/inboxes/email-received

Received when an inbound email is added to a thread.

Event triggered whenever an **inbound email is added to a thread**.

*Note: `source` is always `system`, because the email pipeline sends this event, even when the API or an agent sent the email.*

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.email.received`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.email.received` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread

**email\_id** `string`

The ID of the email

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

**email** `object`

The email, as it is when the webhook is sent, without `html` or `text`. Fetch the body with [Retrieve Thread Email](/docs/api-reference/inboxes/get-thread-email). Absent when the email no longer exists

**email object**

**id** `string`

The ID of the email

**direction** `inbound | outbound`

Whether the email was received by the inbox or sent from it

**from** `string`

Sender email address. Can include the display name.

**to** `string[]`

The recipients of the email

**cc** `string[]`

The CC recipients of the email

**bcc** `string[]`

The BCC recipients of the email

**reply\_to** `string[]`

The Reply-To addresses

**subject** `string | null`

The subject of the email

**message\_id** `string | null`

The Message-ID header of the email

**attachments** `array`

The attachments on the email

**attachment object**

**id** `string`

The ID of the attachment

**filename** `string | null`

The filename of the attachment

**size** `number | null`

The size of the attachment in bytes

**read** `boolean`

Whether the email has been read

**received\_at** `string`

ISO 8601 timestamp when the email arrived or was sent

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.email.received",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "system",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "email_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [],
      "read": false
    },
    "email": {
      "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "direction": "inbound",
      "from": "Steve Wozniak <steve.wozniak@gmail.com>",
      "to": ["support@example.com"],
      "cc": [],
      "bcc": [],
      "reply_to": [],
      "subject": "Question about my invoice",
      "message_id": "<CAF7c1f0a2e5d3b@mail.gmail.com>",
      "attachments": [
        {
          "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
          "filename": "invoice.pdf",
          "size": 48213
        }
      ],
      "read": false,
      "received_at": "2026-09-29T12:00:00.000Z"
    }
  }
}
```


# inbox.email.sent
Source: https://resend.com/docs/webhooks/inboxes/email-sent

Received when an outbound email is accepted for delivery and added to a thread.

Event triggered whenever an **outbound email is accepted for delivery** and added to a thread.

*Note: `source` is always `system`, because the email pipeline sends this event, even when the API or an agent sent the email.*

*Note: When the email comes from a draft, `inbox.draft.sent` is also sent, from the send call. The two events come from separate paths, so their delivery order is not fixed.*

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.email.sent`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.email.sent` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread

**email\_id** `string`

The ID of the email

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

**email** `object`

The email, as it is when the webhook is sent, without `html` or `text`. Fetch the body with [Retrieve Thread Email](/docs/api-reference/inboxes/get-thread-email). Absent when the email no longer exists

**email object**

**id** `string`

The ID of the email

**direction** `inbound | outbound`

Whether the email was received by the inbox or sent from it

**from** `string`

Sender email address. Can include the display name.

**to** `string[]`

The recipients of the email

**cc** `string[]`

The CC recipients of the email

**bcc** `string[]`

The BCC recipients of the email

**reply\_to** `string[]`

The Reply-To addresses

**subject** `string | null`

The subject of the email

**message\_id** `string | null`

The Message-ID header of the email

**attachments** `array`

The attachments on the email

**attachment object**

**id** `string`

The ID of the attachment

**filename** `string | null`

The filename of the attachment

**size** `number | null`

The size of the attachment in bytes

**read** `boolean`

Whether the email has been read

**received\_at** `string`

ISO 8601 timestamp when the email arrived or was sent

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.email.sent",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "system",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "email_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [],
      "read": true
    },
    "email": {
      "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "direction": "outbound",
      "from": "Ada from Support <support@example.com>",
      "to": ["steve.wozniak@gmail.com"],
      "cc": [],
      "bcc": [],
      "reply_to": [],
      "subject": "Re: Question about my invoice",
      "message_id": "<0100019a4ef9a417@email.amazonses.com>",
      "attachments": [],
      "read": true,
      "received_at": "2026-09-29T12:00:00.000Z"
    }
  }
}
```


# inbox.thread.assigned
Source: https://resend.com/docs/webhooks/inboxes/thread-assigned

Received when a thread is assigned or reassigned.

Event triggered whenever a **thread is assigned or reassigned**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.thread.assigned`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.thread.assigned` event contains the following
parameters:

**object parameters**

**assignee\_email** `string | null`

The email of the member the thread is now assigned to

**assigned\_by\_email** `string | null`

The email of the member who made the assignment. `null` when no member made it

**previous\_assignee\_email** `string | null`

The email of the member the thread was assigned to before. `null` when it was unassigned

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.thread.assigned",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "assignee_email": "ada@example.com",
    "assigned_by_email": "grace@example.com",
    "previous_assignee_email": null,
    "source": "dashboard",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [],
      "read": false
    }
  }
}
```


# inbox.thread.created
Source: https://resend.com/docs/webhooks/inboxes/thread-created

Received when the first email of a thread lands in an inbox.

Event triggered whenever the **first email of a thread** lands in the inbox, inbound or outbound.

*Note: `source` is always `system`, because the email pipeline sends this event, even when the API or an agent sent the email.*

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.thread.created`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.thread.created` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread

**email\_id** `string`

The ID of the email

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

**email** `object`

The email, as it is when the webhook is sent, without `html` or `text`. Fetch the body with [Retrieve Thread Email](/docs/api-reference/inboxes/get-thread-email). Absent when the email no longer exists

**email object**

**id** `string`

The ID of the email

**direction** `inbound | outbound`

Whether the email was received by the inbox or sent from it

**from** `string`

Sender email address. Can include the display name.

**to** `string[]`

The recipients of the email

**cc** `string[]`

The CC recipients of the email

**bcc** `string[]`

The BCC recipients of the email

**reply\_to** `string[]`

The Reply-To addresses

**subject** `string | null`

The subject of the email

**message\_id** `string | null`

The Message-ID header of the email

**attachments** `array`

The attachments on the email

**attachment object**

**id** `string`

The ID of the attachment

**filename** `string | null`

The filename of the attachment

**size** `number | null`

The size of the attachment in bytes

**read** `boolean`

Whether the email has been read

**received\_at** `string`

ISO 8601 timestamp when the email arrived or was sent

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.thread.created",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "system",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "email_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [],
      "read": false
    },
    "email": {
      "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      "direction": "inbound",
      "from": "Steve Wozniak <steve.wozniak@gmail.com>",
      "to": ["support@example.com"],
      "cc": [],
      "bcc": [],
      "reply_to": [],
      "subject": "Question about my invoice",
      "message_id": "<CAF7c1f0a2e5d3b@mail.gmail.com>",
      "attachments": [
        {
          "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
          "filename": "invoice.pdf",
          "size": 48213
        }
      ],
      "read": false,
      "received_at": "2026-09-29T12:00:00.000Z"
    }
  }
}
```


# inbox.thread.folder.updated
Source: https://resend.com/docs/webhooks/inboxes/thread-folder-updated

Received when a thread moves between folders.

Event triggered whenever a **thread moves between folders**.

*Note: Moving a thread to a label can send both this event and `inbox.thread.labels.updated` for the same thread.*

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.thread.folder.updated`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.thread.folder.updated` event contains the following
parameters:

**object parameters**

**from** `inbox | archive | spam | trash`

The folder the thread was in

**to** `inbox | archive | spam | trash`

The folder the thread moved to

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.thread.folder.updated",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "from": "inbox",
    "to": "archive",
    "source": "dashboard",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "archive",
      "labels": [],
      "read": true
    }
  }
}
```


# inbox.thread.labels.updated
Source: https://resend.com/docs/webhooks/inboxes/thread-labels-updated

Received when a label is applied to or removed from a thread.

Event triggered whenever a **label is applied to or removed from a thread**.

*Note: Moving a thread to a label can send both this event and `inbox.thread.folder.updated` for the same thread.*

*Note: Deleting a label doesn't send this event for the threads that had it.*

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.thread.labels.updated`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.thread.labels.updated` event contains the following
parameters:

**object parameters**

**added** `array`

The labels applied, each with an `id`, `name`, and `color`. One event carries every label changed by the same request

**removed** `array`

The labels removed, each with an `id`, `name`, and `color`. One event carries every label changed by the same request

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.thread.labels.updated",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "added": [
      {
        "id": "c0a8012e-3b4f-4d7a-9e21-5f6a7b8c9d0e",
        "name": "Billing",
        "color": "#F76B15"
      }
    ],
    "removed": [],
    "source": "dashboard",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [
        {
          "id": "c0a8012e-3b4f-4d7a-9e21-5f6a7b8c9d0e",
          "name": "Billing",
          "color": "#F76B15"
        }
      ],
      "read": false
    }
  }
}
```


# inbox.thread.unassigned
Source: https://resend.com/docs/webhooks/inboxes/thread-unassigned

Received when a thread is unassigned.

Event triggered whenever a **thread is unassigned**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.thread.unassigned`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.thread.unassigned` event contains the following
parameters:

**object parameters**

**previous\_assignee\_email** `string | null`

The email of the member the thread was assigned to

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**thread\_id** `string`

The ID of the thread

**thread** `object`

The thread, as it is when the webhook is sent. Absent when the thread no longer exists

**thread object**

**object** `string`

Always `inbox_thread`

**id** `string`

The ID of the thread

**subject** `string | null`

The subject of the thread

**folder** `inbox | archive | spam | sent | trash`

The folder the thread lives in

**labels** `array`

The labels attached to the thread, each with an `id`, `name`, and `color`

**read** `boolean`

True only when every message in the thread is read

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.thread.unassigned",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "previous_assignee_email": "ada@example.com",
    "source": "dashboard",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "thread_id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
    "thread": {
      "object": "inbox_thread",
      "id": "7c1f0a2e-5d3b-4e8a-9f61-2b8d4c6e1a90",
      "subject": "Question about my invoice",
      "folder": "inbox",
      "labels": [],
      "read": false
    }
  }
}
```


# inbox.updated
Source: https://resend.com/docs/webhooks/inboxes/updated

Received when an inbox's settings change.

Event triggered whenever an **inbox's settings change**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `inbox.updated`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `inbox.updated` event contains the following
parameters:

**object parameters**

**source** `api | dashboard | agent | system`

What made the change

**inbox\_id** `string`

The ID of the inbox

**inbox** `object`

The inbox, as it is when the webhook is sent. Absent when the inbox no longer exists

**inbox object**

**object** `string`

Always `inbox`

**id** `string`

The ID of the inbox

**name** `string`

Internal name for the inbox. Recipients do not see it. Falls back to the inbox
address

**email\_address** `string`

The address of the inbox

**domain\_id** `string`

The ID of the domain the inbox belongs to

**receiving\_address** `string | null`

The address to forward mail to when forwarding is enabled. `null` otherwise

**from\_name** `string | null`

The name recipients see when mail is sent from this inbox. `null` when not set

**unread** `number`

The number of unread threads in the Inbox folder

**drafts** `number`

The number of unsent drafts

**last\_received** `string | null`

ISO 8601 timestamp of the newest received email in the Inbox folder. `null`
when the folder has no received email

**created\_at** `string`

ISO 8601 timestamp when the inbox was created

**updated\_at** `string`

ISO 8601 timestamp set when the inbox is created and updated whenever its name
or from name changes

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "inbox.updated",
  "created_at": "2026-09-29T12:00:00.000Z",
  "data": {
    "source": "dashboard",
    "inbox_id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
    "inbox": {
      "object": "inbox",
      "id": "b3e2b2b6-3f0e-4c8e-9ad3-2f43a1e2c7f1",
      "name": "Customer Support",
      "email_address": "support@example.com",
      "domain_id": "d91cd9bd-1176-453e-8fc1-35364d380206",
      "receiving_address": null,
      "from_name": "Ada from Support",
      "unread": 3,
      "drafts": 2,
      "last_received": "2026-09-29T11:42:08.000Z",
      "created_at": "2026-09-01T09:30:00.000Z",
      "updated_at": "2026-09-03T09:30:00.000Z"
    }
  }
}
```


# Webhook Ingester
Source: https://resend.com/docs/webhooks/ingester

A self-hosted solution to store all your Resend webhook events in your own database.

The Resend Webhook Ingester is an open-source Next.js application that receives, verifies, and stores all your webhook events in your own database. Deploy it to your infrastructure and gain full control over your email event data.

> [!NOTE]
>
> For more details on why you should store your webhook data, see the [data
> storage guide](/docs/webhooks/how-to-store-webhooks-data).

## Why use the Webhook Ingester

While you can build your own webhook handler, the Webhook Ingester provides a production-ready solution with:

* **Signature verification** using Svix to ensure webhook authenticity
* **Idempotent storage** that safely handles duplicate webhook deliveries
* **Multiple database support** including PostgreSQL, MySQL, MongoDB, and data warehouses
* **One-click deployment** to Vercel, Railway, or Render

> [card] [GitHub Repository](https://github.com/resend/resend-webhooks-ingester)
>
> View the source code and contribute

> [card] [Docker Image](https://ghcr.io/resend/resend-webhooks-ingester)
>
> Pull the official Docker image

## Deploy

Get started in minutes with one-click deployment:

[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https://github.com/resend/resend-webhooks-ingester\&env=RESEND_WEBHOOK_SECRET\&envDescription=Your%20Resend%20webhook%20signing%20secret\&envLink=https://resend.com/webhooks)
[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/cd2lvJ?referralCode=w2CHHM\&utm_medium=integration\&utm_source=template\&utm_campaign=generic)
[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/resend/resend-webhooks-ingester)

Or use Docker:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
docker pull ghcr.io/resend/resend-webhooks-ingester
```

## Supported Databases

| Database | Endpoint | Best For |
| - | - | - |
| Supabase | `/supabase` | Quick setup with managed Postgres |
| Neon | `/neon` | Serverless Postgres with branching |
| PostgreSQL | `/postgresql` | Self-hosted or managed Postgres |
| MySQL | `/mysql` | Self-hosted or managed MySQL |
| PlanetScale | `/planetscale` | Serverless MySQL |
| MongoDB | `/mongodb` | Document database (Atlas, self-hosted) |
| Snowflake | `/snowflake` | Data warehousing and analytics |
| BigQuery | `/bigquery` | Google Cloud analytics |
| ClickHouse | `/clickhouse` | High-performance analytics |

## Quick Start

**1. Clone and install**

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
git clone https://github.com/resend/resend-webhooks-ingester.git
cd resend-webhooks-ingester
pnpm install
```

**2. Configure environment variables**

Copy the example environment file and add your credentials:

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
cp .env.example .env.local
```

At minimum, you need:

```env .env.local theme={"theme":{"light":"github-light","dark":"vesper"}}
# Required: Your Resend webhook signing secret
RESEND_WEBHOOK_SECRET=whsec_xxxxxxxxxxxxxxxxxxxxx

# Database credentials (example for PostgreSQL)
POSTGRESQL_URL=postgresql://user:password@host:5432/database
```

> [!NOTE]
>
> Get your webhook signing secret from the [Resend
> Dashboard](https://resend.com/webhooks) when creating a webhook.

**3. Set up your database**

Set up your database and run the provided schema for your database. The ingester supports PostgreSQL, MySQL, MongoDB, and several data warehouses. Schema files can be found in the `schemas/` directory.

```bash theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm db:setup --postgresql
# or use a different flag for a different database
```

**4. Deploy and register webhook**

Deploy to your preferred platform, then register your webhook endpoint in the [Resend Dashboard](https://resend.com/webhooks) and select all the events you'd like to store.

Your endpoint URL will be: `https://example.com/{connector}`

For example: `https://your-app.vercel.app/postgresql`

## Database Schemas

The ingester creates three tables to store webhook events:

| Table | Description |
| - | - |
| `resend_wh_emails` | All email events (sent, delivered, bounced, opened, clicked) |
| `resend_wh_contacts` | Contact events (created, updated, deleted) |
| `resend_wh_domains` | Domain events (created, updated, deleted) |

Each table includes:

* `svix_id` - Unique webhook event ID for idempotency
* `event_type` - The type of event (e.g., `email.delivered`)
* `event_created_at` - When the event occurred
* `webhook_received_at` - When the webhook was received
* Event-specific fields (e.g., email details, bounce info, click data)

## Idempotency

The ingester handles duplicate webhooks automatically. Each webhook includes a unique `svix-id` header, and the ingester uses this to ensure events are stored only once.

If Resend retries a webhook delivery (due to a temporary failure), the duplicate will be safely ignored without creating duplicate records in your database.

## Configuration Reference

### Required Environment Variables

| Variable | Description |
| - | - |
| `RESEND_WEBHOOK_SECRET` | Your webhook signing secret from Resend |

### Database-Specific Variables

> [accordion] Supabase
>
> ```env theme={"theme":{"light":"github-light","dark":"vesper"}}
> SUPABASE_URL=https://your-project.supabase.co
> SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
> ```

> [accordion] Neon
>
> ```env theme={"theme":{"light":"github-light","dark":"vesper"}}
> NEON_DATABASE_URL=postgresql://user:password@ep-xyz.us-east-1.aws.neon.tech/database?sslmode=require
> ```

> [accordion] PostgreSQL
>
> ```env theme={"theme":{"light":"github-light","dark":"vesper"}}
> POSTGRESQL_URL=postgresql://user:password@host:5432/database
> ```

> [accordion] MySQL
>
> ```env theme={"theme":{"light":"github-light","dark":"vesper"}}
> MYSQL_URL=mysql://user:password@host:3306/database
> ```

> [accordion] PlanetScale
>
> ```env theme={"theme":{"light":"github-light","dark":"vesper"}}
> PLANETSCALE_URL=mysql://username:password@host/database?ssl={"rejectUnauthorized":true}
> ```

> [accordion] MongoDB
>
> ```env theme={"theme":{"light":"github-light","dark":"vesper"}}
> MONGODB_URI=mongodb+srv://username:password@cluster.mongodb.net/
> MONGODB_DATABASE=resend_webhooks
> ```

> [accordion] Snowflake
>
> ```env theme={"theme":{"light":"github-light","dark":"vesper"}}
> SNOWFLAKE_ACCOUNT=your-account-identifier
> SNOWFLAKE_USERNAME=your-username
> SNOWFLAKE_PASSWORD=your-password
> SNOWFLAKE_DATABASE=your-database
> SNOWFLAKE_SCHEMA=your-schema
> SNOWFLAKE_WAREHOUSE=your-warehouse
> ```

> [accordion] BigQuery
>
> ```env theme={"theme":{"light":"github-light","dark":"vesper"}}
> BIGQUERY_PROJECT_ID=your-project-id
> BIGQUERY_DATASET_ID=your-dataset-id
> BIGQUERY_CREDENTIALS={"type":"service_account","project_id":"..."}
> ```

> [accordion] ClickHouse
>
> ```env theme={"theme":{"light":"github-light","dark":"vesper"}}
> CLICKHOUSE_URL=https://your-instance.clickhouse.cloud:8443
> CLICKHOUSE_USERNAME=default
> CLICKHOUSE_PASSWORD=your-password
> CLICKHOUSE_DATABASE=default
> ```

## Example Queries

Once your data is stored, you can run analytics queries. Here's an example to get email status counts by day:

```sql PostgreSQL theme={"theme":{"light":"github-light","dark":"vesper"}}
SELECT
  DATE(event_created_at) AS day,
  event_type,
  COUNT(*) AS count
FROM resend_wh_emails
GROUP BY DATE(event_created_at), event_type
ORDER BY day DESC, event_type;
```

```javascript MongoDB theme={"theme":{"light":"github-light","dark":"vesper"}}
db.resend_wh_emails.aggregate([
  {
    $group: {
      _id: {
        day: {
          $dateToString: { format: '%Y-%m-%d', date: '$event_created_at' },
        },
        event_type: '$event_type',
      },
      count: { $sum: 1 },
    },
  },
  { $sort: { '_id.day': -1 } },
]);
```

```sql ClickHouse theme={"theme":{"light":"github-light","dark":"vesper"}}
SELECT
  toDate(event_created_at) AS day,
  event_type,
  count() AS count
FROM resend_wh_emails
FINAL
GROUP BY day, event_type
ORDER BY day DESC, event_type;
```

> [!NOTE]
>
> See the
> [queries\_examples.md](https://github.com/resend/resend-webhooks-ingester/blob/main/queries_examples.md)
> file in the repository for more analytics queries including bounce rates, open
> rates, and click-through rates.

## Data Retention

By default, webhook events are stored indefinitely. To implement data retention policies, you can set up scheduled jobs to delete old events.

Example for PostgreSQL (delete events older than 90 days):

```sql theme={"theme":{"light":"github-light","dark":"vesper"}}
DELETE FROM resend_wh_emails
WHERE event_created_at < NOW() - INTERVAL '90 days';
```

> [!TIP]
>
> For Supabase, use
> [pg\_cron](https://supabase.com/docs/guides/database/extensions/pg_cron) to
> schedule cleanup queries. For MongoDB, consider using [TTL
> indexes](https://www.mongodb.com/docs/manual/core/index-ttl/) or [Atlas
> scheduled
> triggers](https://www.mongodb.com/docs/atlas/app-services/triggers/scheduled-triggers/).

## Troubleshooting

> [accordion] Webhook signature verification failing
>
> * Ensure `RESEND_WEBHOOK_SECRET` matches the signing secret in your Resend
>   Dashboard - Make sure you're using the raw request body for verification -
>   Check that the secret hasn't been rotated in Resend

> [accordion] Database connection errors
>
> * Verify your database credentials are correct - Check that the schema has
>   been applied to your database - Ensure your database is accessible from your
>   deployment (check firewall rules)

> [accordion] Webhooks not being received
>
> * Verify your endpoint URL is publicly accessible - Check the webhook status
>   in your [Resend Dashboard](https://resend.com/webhooks) - Ensure your server
>   responds with HTTP 200 for successful requests

## Learn More

> [card] [Webhook Event Types](/docs/webhooks/event-types)
>
> View all available webhook event types and their payloads

> [card] [Verify Webhooks](/docs/webhooks/verify-webhooks-requests)
>
> Learn how webhook signature verification works

> [card] [Retries and Replays](/docs/webhooks/retries-and-replays)
>
> Understand webhook retry behavior

> [card] [Storing Webhooks Data](/docs/webhooks/how-to-store-webhooks-data)
>
> Learn why and how to store your webhook data


# Webhooks
Source: https://resend.com/docs/webhooks/introduction

An introduction to using webhooks to notify your application about email events.

## Webhooks

Resend provides webhooks, which are real-time HTTPS requests that tell your application an event occurred, such as an email delivery notification or subscription status update. This allows you to receive real-time and actionable updates on the delivery, open, bounce, and click events of your emails.
You can create, update, observe, and retry webhooks from the dashboard or [via the API](/docs/api-reference/webhooks/create-webhook).

Webhooks deliver a JSON payload with metadata like the from, to, and status of your email event that can be used by your application. Use webhook feeds for common workflows such as:

* Automatically remove [bounced email addresses](/docs/webhooks/emails/bounced) from mailing lists.
* Create alerts in your messaging or incident tools based on [event types](/docs/webhooks/event-types).
* [Store all send events](/docs/webhooks/how-to-store-webhooks-data) in your own database for custom reporting/retention.
* [Receive inbound emails](/docs/dashboard/receiving/introduction) from your application.

## Webhook features

With Resend's webhook features, you can:

* [Replay any webhook event](/docs/webhooks/retries-and-replays). This is useful when your endpoint missed an event, or when you want to reprocess events with updated handler code.
* [Verify webhook requests](/docs/webhooks/verify-webhooks-requests) to ensure their authenticity.
* [Listen for webhook events locally during development](/docs/cli#webhooks).
* Self-host the [Resend Webhook Ingester](/docs/webhooks/ingester) to store all your webhook events with an open-source, ready-to-deploy solution that handles all the complexity for you.

## Quickstart

Get started by [creating a webhook](/docs/webhooks/create-webhook) to incorporate Resend into your application.

To receive real-time events in your app via webhooks, you need to:

**1. Create an endpoint in your application**

Create a route that can accept POST requests. This route will listen for and
receive events from Resend.

**2. Add a webhook in Resend**

Define a webhook with the URL of your endpoint, and the [email
events](/docs/webhooks/event-types) it handles.

See a step-by-step example of [creating a webhook](/docs/webhooks/create-webhook) through the Dashboard, including testing and deployment.

## Choose your infrastructure

After creating your application endpoint, you can define and manage your webhooks entirely from the Resend Dashboard. This allows all members of your team to have full access to your email event data and to perform any necessary maintenance.

To build workflows to manage and respond to email events from your application, you can use a variety of tools:

* [SDK](/docs/sdks): build and manage webhooks with an SDK built for your language
* [Integrations](/docs/integrations): build workflows with a framework or tool you already use
* [API](/docs/api-reference/webhooks/create-webhook): manage webhooks with raw cURL calls
* [CLI](/docs/cli#webhooks): register endpoints and listen for email event notifications from the terminal.
* [MCP](/docs/mcp-server): build workflows that respond to email events through your agent using natural language.

See how to use Resend's webhook features such as replaying webhooks and storing webhook data in the [webhooks guides](#related-guides).

## Related Guides

> [card] [Create webhook](/docs/webhooks/create-webhook)

> [card] [Respond to emails](/docs/dashboard/receiving/create-receiving-webhook)

> [card] [Retry replay webhooks](/docs/webhooks/retries-and-replays)

> [card] [Email event types](/docs/webhooks/event-types)

> [card] [Verify a webhook request](/docs/webhooks/verify-webhooks-requests)

> [card] [Store webhook data](/docs/webhooks/how-to-store-webhooks-data)

> [card] [Self-host the Resend Webhook Ingester](/docs/webhooks/ingester)

> [card] [Webhook events reference](/docs/webhooks/emails/bounced)

## Examples

> [card] [Next.js (TypeScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/typescript/src/app/inbound)
>
> See the full source code.

> [card] [Next.js (JavaScript)](https://github.com/resend/resend-examples/tree/main/nextjs-resend-examples/javascript/src/app/inbound)
>
> See the full source code.

> [card] [PHP](https://github.com/resend/resend-examples/tree/main/php-resend-examples/src/inbound)
>
> See the full source code.

> [card] [Laravel](https://github.com/resend/resend-examples/tree/main/laravel-resend-examples)
>
> See the full source code.

> [card] [Python](https://github.com/resend/resend-examples/tree/main/python-resend-examples/examples)
>
> See the full source code.

> [card] [Ruby](https://github.com/resend/resend-examples/tree/main/ruby-resend-examples/examples)
>
> See the full source code.


# Retries and Replays
Source: https://resend.com/docs/webhooks/retries-and-replays

Learn how to use the retries and replays to handle webhook failures.

## Automatic Retries

Resend attempts to deliver each webhook message based on a schedule with exponential backoff.

Each message is attempted based on the following schedule, where each period is started following the failure of the preceding attempt:

* Immediately
* 5 seconds
* 5 minutes
* 30 minutes
* 2 hours
* 5 hours
* 10 hours
* 10 hours (in addition to the previous)

For example, an attempt that fails three times before eventually succeeding will be delivered roughly 35 minutes and 5 seconds following the first attempt.

If an endpoint is removed or disabled, delivery attempts to the endpoint will be disabled as well.

To see when a message will be retried next, check the webhook message details in the dashboard.

## Failure notifications

If a webhook endpoint keeps failing to receive events, Resend disables it automatically and sends an email notification to your team. The email includes the endpoint URL and, when known, how long the endpoint had been failing. Once your endpoint is back up, you can re-enable it from the [Webhooks](https://resend.com/webhooks) page in the dashboard.

## Manual Replays

If a webhook message fails, you can manually replay it.

You can replay both `failed` and `succeeded` webhook messages.

![Replay Webhook](https://mintcdn.com/resend/qZ1nhePh39wY_UO4/images/webhooks-replay-1.jpg?fit=max\&auto=format\&n=qZ1nhePh39wY_UO4\&q=85\&s=aeae9936eeea92d71da580af9f82cbb5)

Here's how to replay a webhook message:

1. Go to the [Webhooks](https://resend.com/webhooks) page
2. Navigate to the Webhook Endpoint you are using
3. Go to the Webhook Message you want to replay
4. Click on the "Replay" button


# suppression.added
Source: https://resend.com/docs/webhooks/suppressions/added

Received when an email address is added to your suppression list.

Event triggered whenever an **email address is added to your suppression
list**. Addresses are added automatically after a hard bounce or spam
complaint, or manually through the dashboard or API.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `suppression.added`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `suppression.added` event contains the following
parameters:

**object parameters**

**id** `string`

Unique identifier for the suppression

**email** `string`

The suppressed email address

**origin** `string`

How the address was suppressed: `bounce`, `complaint`, or `manual`

**source\_id** `string | null`

ID of the email that triggered the suppression. For suppressions with a
`manual` origin, `source_id` is `null`

**created\_at** `string`

ISO 8601 timestamp when the suppression was created

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "suppression.added",
  "created_at": "2026-11-17T19:32:22.980Z",
  "data": {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "email": "steve.wozniak@gmail.com",
    "origin": "bounce",
    "source_id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
    "created_at": "2026-11-17T19:32:22.980Z"
  }
}
```


# suppression.removed
Source: https://resend.com/docs/webhooks/suppressions/removed

Received when an email address is removed from your suppression list.

Event triggered whenever an **email address is removed from your suppression
list**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `suppression.removed`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `suppression.removed` event contains the following
parameters:

**object parameters**

**id** `string`

Unique identifier for the suppression

**email** `string`

The suppressed email address

**origin** `string`

How the address was suppressed: `bounce`, `complaint`, or `manual`

**source\_id** `string | null`

ID of the email that triggered the suppression. For suppressions with a
`manual` origin, `source_id` is `null`

**created\_at** `string`

ISO 8601 timestamp when the suppression was created

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "suppression.removed",
  "created_at": "2026-11-17T19:32:22.980Z",
  "data": {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "email": "steve.wozniak@gmail.com",
    "origin": "manual",
    "source_id": null,
    "created_at": "2026-11-15T08:12:45.120Z"
  }
}
```


# topic.created
Source: https://resend.com/docs/webhooks/topics/created

Received when a topic is created.

Event triggered whenever a **topic is created**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `topic.created`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `topic.created` event contains the following
parameters:

**object parameters**

**id** `string`

Unique identifier for the topic

**name** `string`

The topic name

**description** `string | null`

The topic description

**default\_subscription** `opt_in | opt_out`

The default subscription preference for new contacts

**deleted** `boolean`

Whether the topic was deleted

**created\_at** `string`

ISO 8601 timestamp when the topic was created

**updated\_at** `string`

ISO 8601 timestamp when the topic was last updated

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "topic.created",
  "created_at": "2026-02-12T10:00:00.000Z",
  "data": {
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    "name": "Product Updates",
    "description": "New features and improvements",
    "default_subscription": "opt_in",
    "deleted": false,
    "created_at": "2026-02-12T10:00:00.000Z",
    "updated_at": "2026-02-12T10:00:00.000Z"
  }
}
```


# topic.deleted
Source: https://resend.com/docs/webhooks/topics/deleted

Received when a topic is deleted.

Event triggered whenever a **topic is deleted**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `topic.deleted`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `topic.deleted` event contains the following
parameters:

**object parameters**

**id** `string`

Unique identifier for the topic

**name** `string`

The topic name

**description** `string | null`

The topic description

**default\_subscription** `opt_in | opt_out`

The default subscription preference for new contacts

**deleted** `boolean`

Whether the topic was deleted

**created\_at** `string`

ISO 8601 timestamp when the topic was created

**updated\_at** `string`

ISO 8601 timestamp when the topic was last updated

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "topic.deleted",
  "created_at": "2026-02-12T10:00:00.000Z",
  "data": {
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    "name": "Product Updates",
    "description": "New features and improvements",
    "default_subscription": "opt_in",
    "deleted": true,
    "created_at": "2026-02-12T10:00:00.000Z",
    "updated_at": "2026-02-12T10:00:00.000Z"
  }
}
```


# topic.updated
Source: https://resend.com/docs/webhooks/topics/updated

Received when a topic is updated.

Event triggered whenever a **topic is updated**.

## Response Body Parameters

All webhook payloads follow a consistent top-level structure with
event-specific data nested within the `data` object.

**type** `string`

The event type that triggered the webhook (e.g., `topic.updated`).
**created\_at** `string`

ISO 8601 timestamp when the webhook event was created.
**data** `object`

Event-specific data containing detailed information about the event. The
data object for the `topic.updated` event contains the following
parameters:

**object parameters**

**id** `string`

Unique identifier for the topic

**name** `string`

The topic name

**description** `string | null`

The topic description

**default\_subscription** `opt_in | opt_out`

The default subscription preference for new contacts

**deleted** `boolean`

Whether the topic was deleted

**created\_at** `string`

ISO 8601 timestamp when the topic was created

**updated\_at** `string`

ISO 8601 timestamp when the topic was last updated

```json theme={"theme":{"light":"github-light","dark":"vesper"}}
{
  "type": "topic.updated",
  "created_at": "2026-02-12T10:00:00.000Z",
  "data": {
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    "name": "Product Updates",
    "description": "New features and improvements",
    "default_subscription": "opt_in",
    "deleted": false,
    "created_at": "2026-02-12T10:00:00.000Z",
    "updated_at": "2026-02-12T10:00:00.000Z"
  }
}
```


# Verify Webhooks Requests
Source: https://resend.com/docs/webhooks/verify-webhooks-requests

Learn how to use the signing secret to verify your webhooks.

Webhook signing secrets are used to validate the payload data sent to your application from Resend. You can find the signing secret on the webhook details page.

![Signing Secret](https://mintcdn.com/resend/qZ1nhePh39wY_UO4/images/webhooks-secret-1.png?fit=max\&auto=format\&n=qZ1nhePh39wY_UO4\&q=85\&s=fa5955e5da08d6263850dfd024c642bb)

Calls to [create](/docs/api-reference/webhooks/create-webhook), [retrieve](/docs/api-reference/webhooks/get-webhook), or [list](/docs/api-reference/webhooks/list-webhooks) webhooks will also return the signing secret in the response body.

## How to verify webhook requests

To verify the webhook request, you can use the Resend SDK, as in the example below.

> [!TIP]
>
> Make sure that you're using the raw request body when verifying webhooks. The
> cryptographic signature is sensitive to even the slightest change. Some
> frameworks parse the request as JSON and then stringify it, and this will also
> break the signature verification.

```js theme={"theme":{"light":"github-light","dark":"vesper"}}
export async function POST(req: NextRequest) {
  try {
    const payload = await req.text();

    // Throws an error if the webhook is invalid
    // Otherwise, returns the parsed payload object
    const result = resend.webhooks.verify({
      payload,
      headers: {
        id: req.headers['svix-id'],
        timestamp: req.headers['svix-timestamp'],
        signature: req.headers['svix-signature'],
      },
      webhookSecret: process.env.RESEND_WEBHOOK_SECRET,
    });

    // Handle the result after validating it
  } catch {
    return new NextResponse('Invalid webhook', { status: 400 });
  }
}
```

Alternatively, you can manually use the Svix libraries and manually pass it the headers, body, and webhook secret. [Learn more and view all supported languages here.](https://docs.svix.com/receiving/verifying-payloads/how)

To verify manually, start by installing the Svix libaries.

```sh npm theme={"theme":{"light":"github-light","dark":"vesper"}}
npm install svix
```

```sh yarn theme={"theme":{"light":"github-light","dark":"vesper"}}
yarn add svix
```

```sh pnpm theme={"theme":{"light":"github-light","dark":"vesper"}}
pnpm add svix
```

```sh bun theme={"theme":{"light":"github-light","dark":"vesper"}}
bun add svix
```

Then, verify the webhooks using the code below. The payload is the raw (string) body of the request, and the headers are the headers passed in the request.

```js theme={"theme":{"light":"github-light","dark":"vesper"}}
import { Webhook } from 'svix';

const secret = process.env.WEBHOOK_SECRET;

// These were all sent from the server
const headers = {
  'svix-id': 'msg_p5jXN8AQM9LWM0D4loKWxJek',
  'svix-timestamp': '1614265330',
  'svix-signature': 'v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=',
};
const payload = '{"test": 2432232314}';

const wh = new Webhook(secret);
// Throws on error, returns the verified content on success
wh.verify(payload, headers);
```

If you prefer, you can also [manually verify the headers as well.](https://docs.svix.com/receiving/verifying-payloads/how-manual)

## Why verify webhooks

Webhooks are vulnerable because attackers can send fake HTTP POST requests to endpoints, pretending to be legitimate services. This can lead to security risks or operational issues.

To mitigate this, each webhook and its metadata are signed with a unique key specific to the endpoint. This signature helps verify the source of the webhook, allowing only authenticated webhooks to be processed.

Another security concern is replay attacks, where intercepted valid payloads, complete with their signatures, are resent to endpoints. These payloads would pass the signature verification and be executed, posing a potential security threat.

## API Reference

For complete API documentation, see the [Webhooks API reference](/docs/api-reference/webhooks/create-webhook).