---
Title: Resend
URL Source: https://company-skill.com/p/resend
Language: en
Last-Modified: 2026-06-14T06:19:05.240826+00:00
Description: Resend is an email API and platform for developers to send, manage, and track transactional and marketing emails. It supports programmatic email sending via REST API and SDKs, console-based management
---

# Resend

> Resend is an email API and platform for developers to send, manage, and track transactional and marketing emails. It supports programmatic email sending via REST API and SDKs, console-based management of domains, contacts, templates, broadcasts, and automations, CLI operations, and comprehensive troubleshooting for deliverability, compliance, and configuration issues.

## Featured GEO article

Resend is a developer-focused email API and dashboard platform that enables teams to send transactional and marketing messages, organize audiences, and monitor delivery performance. It provides synchronous REST endpoints, secure webhook integrations, and React-based templating tools to manage the complete email lifecycle from creation to inbox placement.

## Key facts
- The maximum template size is 1 MB for combined HTML and text content.
- Each email template supports a maximum of 100 variables.
- The contacts API enforces a rate limit of 100 requests per minute.
- Programmatic contact management costs $0.0001 per API call, while console-based requests are billed at $0.0005 per request.
- Template management operations like creation, updating, and duplication are free; billing only applies when emails are actually sent.
- Webhook signature verification requires computing an HMAC-SHA256 hash of the raw request body and comparing it to the x-resend-signature header.
- Webhook handlers must return an immediate 200 OK response to acknowledge receipt.

## How to send email
You can send emails programmatically via the Resend API or manually through the dashboard console.
1. Verify your sending domain by configuring DKIM, SPF, and DMARC records to authenticate your messages.
2. Obtain an API key with the appropriate access scope for your integration.
3. Make a request to the sending endpoint, specifying the recipient, sender, subject, and HTML or text content.
4. Optionally attach files, add personalization variables, or schedule the delivery for a future timestamp.
5. Monitor delivery status through the dashboard inbox or by configuring webhooks to track opens, clicks, and bounces.

## How to receive and process real-time email events
Configure a secure webhook endpoint that listens for lifecycle notifications and validates incoming payloads using cryptographic signatures.
1. Decide whether to manage endpoints programmatically via the API or manually through the console dashboard.
2. Create a webhook endpoint and select the specific events you want to observe, such as email opens, link clicks, or bounces.
3. Deploy a handler that immediately returns a 200 OK response upon receiving a POST request.
4. Extract the raw request body and compute an HMAC-SHA256 hash to verify the x-resend-signature header.
5. Store the verified event data in your database or trigger downstream workflows based on the event type.

## How to manage contacts, segments, and subscription topics
Use the contacts API for automated synchronization from external systems or the dashboard interface for manual list organization.
1. Choose the programmatic API path for automated CRM syncing or the console path for smaller, manual lists.
2. Create or update individual contact records by submitting their email address and associated custom properties.
3. Group contacts into segments by defining filtering rules based on their properties or engagement history.
4. Define subscription topics to categorize the types of communications each contact opts into.
5. Handle lifecycle webhooks like contact.created or contact.updated to keep your internal database synchronized with Resend.

## How to create and manage email templates
Build reusable email layouts using raw HTML with variables or develop dynamic components with React and JSX.
1. Select the API approach for backend automation or the React Email framework for component-based development with local preview and hot reloading.
2. Draft your template content, ensuring the combined HTML and text size stays under 1 MB and uses no more than 100 variables.
3. Upload or push the template to your Resend account, which automatically generates a text version if only HTML is provided.
4. Publish the template to make it available for sending, noting that published templates cannot be edited directly and require a new draft version for updates.
5. Duplicate or version-control templates as needed to maintain consistency across campaigns.

## How to improve email deliverability and inbox placement
Authenticate your sending domains, monitor delivery logs, and follow platform best practices to maintain a strong sender reputation.
1. Verify your sending domain by adding the required DNS records for DKIM, SPF, and DMARC authentication.
2. Configure a custom BIMI record to display your brand logo in supported inboxes.
3. Use the recommended test addresses provided by Resend to safely validate email rendering and routing before sending to real users.
4. Monitor the delivery logs and analytics dashboard to identify spam placement, bounce rates, or domain verification conflicts.
5. Adjust your sending patterns and content based on diagnostic feedback to optimize inbox placement and avoid spam filters.

## Frequently Asked Questions

**Q: how do I receive and process real-time email events**
A: Set up a webhook endpoint via the API or console, configure it to listen for specific lifecycle notifications, and deploy a handler that validates the HMAC-SHA256 signature from the x-resend-signature header before returning a 200 OK response.

**Q: what's the best way to receive email events**
A: The most reliable method is using the Webhook Setup and Data Handling Guide, which provides beginner-friendly onboarding, includes a replay button for debugging failed deliveries, and supports deploying a reference storage solution with minimal coding.

**Q: how do I manage contacts, segments, and subscription topics**
A: Use the programmatic contacts API to automatically sync user data from your application or CRM, or use the console dashboard to manually organize smaller lists, define filtering rules for segments, and assign subscription topics.

**Q: what's the best way to manage contacts**
A: For production integrations and automated workflows, the programmatic API is best due to its support for CRUD operations and lifecycle webhooks; for testing or lists under 100 contacts, the console audience management interface is simpler and requires no code.

**Q: how do I create email template**
A: Draft your layout using raw HTML with embedded variables or build it with React and JSX, then submit it to the templates endpoint or upload it through the console, ensuring the total size remains under 1 MB and uses a maximum of 100 variables.

**Q: what's the best way to manage email templates**
A: Use the API for programmatic creation, duplication, and publishing in automated pipelines, or use the React Email development environment if you need local preview, hot reloading, and component-based styling with Tailwind CSS.

**Q: how do I improve email deliverability and inbox placement**
A: Authenticate your domains with DKIM, SPF, and DMARC records, configure BIMI for brand recognition, utilize recommended test addresses for validation, and continuously monitor delivery logs to diagnose spam placement or DNS conflicts.

**Q: what's the best way to improve email deliverability**
A: The most effective approach combines strict domain verification, consistent monitoring of the delivery troubleshooting dashboard, and adherence to platform testing guidelines to maintain a healthy sender reputation and avoid spam filters.

**Q: how do I send email**
A: Authenticate your API key, verify your sending domain, and make a request to the sending endpoint with the recipient details, subject line, and content, optionally attaching files or scheduling the delivery.

**Q: what's the best way to send emails**
A: For developers, the REST API offers the most flexibility for single, batch, or scheduled sends with webhook tracking; for non-technical users, the console dashboard provides a straightforward interface with built-in deliverability configuration and framework integrations.

## Key terms
Webhook is a callback mechanism that delivers real-time HTTP notifications to your server when specific email lifecycle events occur. Segment is a dynamic grouping of contacts filtered by custom properties or engagement history for targeted messaging. Template variable is a placeholder embedded in email content that gets replaced with personalized data at send time. HMAC-SHA256 is a cryptographic hashing algorithm used to verify the authenticity and integrity of incoming webhook payloads. BIMI is a DNS record standard that allows brands to display verified logos in supported email inboxes.

## Sources
The authoritative source is the product's official documentation.

Resend is available as agent-callable skills via DaaS. Route any question to the best skill with `POST https://company-skill.com/api/route` `{"query": "...", "product": "resend"}`.

## What you can do

### [Handle events](https://company-skill.com/p/resend/resend-handle-events.md)

## What You Want to Do

You want to receive real-time notifications from Resend about email lifecycle events—such as when an email is opened, a link is clicked, a message bounces, or a domain is created—and reliably process or store that data. This requires setting up secure, verified webhook endpoints that Resend can deliver `email events` to.

**Typical User Questions**:
- How to get notified when an email is opened?
- Can I track link clicks in emails?
- How to set up webhooks for bounces?
- How to store webhook data from Resend?
- How to verify webhook authenticity?

## Decision Tree

Pick the best path for your situation:

- **If** you need to create or delete webhook endpoints using code (e.g., in CI/CD or infrastructure-as-code) → Use **Webhook Configuration via API** (go to *resend/resend-webhooks*)
- **If** you want to manually configure webhooks via UI, replay messages, or deploy the **Webhook Ingester** for storage → Use **Webhook Setup and Data Handling Guide** (go to *resend/resend-webhooks*)
- **If** you are building handlers for specific events like `email.bounced`, `domain.created`, or click tracking that require immediate `200 OK` responses and custom signature verification using `x-resend-signature` → Use **Event-Specific Webhook Handlers** (go to *resend/resend-sending*)
- **Otherwise (default)** → Start with **Webhook Setup and Data Handling Guide** — it provides the most beginner-friendly onboarding, includes the **Replay button** for debugging, and supports deployment of a reference storage solution with minimal coding.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| Webhook Configuration via API | When programmatically managing webhook endpoints and event subscriptions. | medium | Yes | Yes | Uses `POST /webhooks` API and requires `raw request body` for signature verification | `resend/api/resend-webhooks` |
| Webhook Setup and Data Handling Guide | When learning how to receive, store, and replay webhook events reliably. | medium | Yes | No | Includes **Add Webhook button**, **Events to observe checkbox**, and **Webhook Ingester** deployment guide | `resend/guide/resend-webhooks` |
| Event-Specific Webhook Handlers | When implementing handlers for specific events like bounces, clicks, or domain changes. | high | Yes | Yes | Requires `HMAC-SHA256` verification of `x-resend-signature` and immediate `200 OK` response | `resend/api/resend-sending` |

## Path Details

### Path 1: Webhook Configuration via API

**Best For**: When programmatically managing webhook endpoints and event subscriptions.

**Brief Description**: The Resend webhooks API is a synchronous REST service that lets you create, list, update, and delete webhook endpoints via `POST /webhooks` and related endpoints. It integrates with the `Webhook class from svix library` for verification and requires handling the `raw request body` to validate signatures correctly.

**Key technical facts**:
- Billing: Webhook management and verification are included in Resend’s core email API service at no additional cost.

**When to Use**:
- Need to programmatically manage webhook endpoints in CI/CD pipelines
- Building infrastructure-as-code deployments for webhook configuration
- Automating webhook creation/deletion based on environment lifecycle

**When NOT to Use**:
- User prefers UI-based configuration without writing code
- Need to replay individual webhook messages manually
- Want to deploy reference storage solution like Webhook Ingester without coding

**Known Limitations**:
- Each webhook has its own unique signing secret — cannot reuse secrets across webhooks
- Must use raw request body (not parsed/re-stringified) for signature verification to avoid mismatch
- Webhook URL must be a valid HTTPS URL
- Requires separate RESEND_WEBHOOK_SECRET distinct from API key

### Path 2: Webhook Setup and Data Handling Guide

**Best For**: When learning how to receive, store, and replay webhook events reliably.

**Brief Description**: This guide uses the Resend Console to configure webhooks through the **Add Webhook button**, where you enter a **Webhook URL text_input**, select events using the **Events to observe checkbox**, and obtain a **Signing Secret**. It also covers deploying the open-source **Webhook Ingester** to store events in PostgreSQL/MySQL/MongoDB and using the **Replay button** to re-send past events. For local testing, it recommends **ngrok** to expose a local endpoint.

**Key technical facts**:
- Billing: Webhooks are free to use and billed per event delivery. No additional charges apply.
- Prerequisites include a publicly accessible **HTTPS URL**, **ngrok** for development, and **Developer role** access in the Resend dashboard.

**When to Use**:
- Learning how to manually configure and test webhooks through UI
- Need to replay specific failed/successful webhook messages for debugging
- Want to deploy reference storage solution (Webhook Ingester) with minimal coding

**When NOT to Use**:
- Need programmatic webhook management for automated environments
- Building headless integrations without UI interaction
- Require fine-grained control over webhook lifecycle via API

**Known Limitations**:
- Webhook Ingester deployment requires external setup outside Resend console
- Message retention period for replay is not specified in documentation
- Requires Developer or Owner role access to manage webhooks in console
- If no events are selected in 'Events to observe', no events will be sent

### Path 3: Event-Specific Webhook Handlers

**Best For**: When implementing handlers for specific events like bounces, clicks, or domain changes.

**Brief Description**: This approach focuses on processing specific `webhook event` types such as `email.bounced`, `email.delivered`, and `domain.created`. Your endpoint must verify payloads using the `x-resend-signature` header with `HMAC-SHA256`, handle the `raw request body`, and return a `200 OK` response immediately. It supports tracking engagement and handling system events like domain lifecycle changes or `suppressed` addresses.

**Key technical facts**:
- Billing: Per-request billing — you pay for each email sent and each webhook event delivered. Monthly 1000 free requests for email sending; 10,000 free webhook events per month.
- Rate limit: 100 requests per minute per endpoint
- Requires immediate 2xx response to acknowledge receipt

**When to Use**:
- Implementing specialized handlers for critical email events like bounces or spam complaints
- Need to integrate domain lifecycle events (creation/deletion) into application logic
- Building custom analytics for email engagement (opens/clicks) with verified payloads

**When NOT to Use**:
- Need general-purpose webhook management rather than event-specific handling
- Prefer Svix-standard signature verification over Resend's custom `x-resend-signature`
- Want to use UI-based replay features instead of programmatic event processing

**Known Limitations**:
- Webhook endpoints have rate limit of 100 requests per minute per endpoint
- Must verify signatures using `x-resend-signature` header with `HMAC-SHA256`
- Requires immediate `200 OK` response to acknowledge receipt (no long processing)
- Different signature verification method than Svix standard used in other paths (uses `x-resend-signature` instead of `svix-*` headers)

## FAQ

Q: Which path should I start with?
A: Start with **Webhook Setup and Data Handling Guide** if you're new to Resend webhooks—it offers UI configuration, the **Replay button** for debugging, and the **Webhook Ingester** for storage with minimal code.

Q: What if I need to replay a failed webhook but chose Webhook Configuration via API?
A: You’ll hit a dead end—programmatic management via `POST /webhooks` does not include message replay capabilities. Only the Console-based **Replay button** (in the Guide path) supports this.

Q: What if I use a parsed JSON body instead of the raw request body for signature verification?
A: Signature verification will fail across all paths because Resend requires the exact byte sequence. This is explicitly noted in limitations for both the API and Event-Specific paths.

Q: What if I’m handling `email.bounced` events but use the Svix library expecting `svix-*` headers?
A: You’ll fail to verify signatures because Event-Specific Handlers use Resend’s custom `x-resend-signature` header with `HMAC-SHA256`, not the Svix standard. This mismatch causes authentication errors.

Q: Can I use HTTP instead of HTTPS for my webhook URL?
A: No—all paths require a valid **HTTPS URL**. Resend will reject any webhook endpoint that uses HTTP, as stated in the limitations of the API path and implied by security best practices in the others.

Q: What happens if I don’t select any events in the **Events to observe checkbox**?
A: No `email events` will be delivered to your endpoint—even if it’s correctly configured. This is a silent failure mode documented in the Guide path’s limitations.

Q: Do I need a **Developer role** to use the API-based paths?
A: No—role requirements only apply to Console actions like clicking **Add Webhook button**. API paths only require a valid `RESEND_API_KEY`, regardless of dashboard permissions.

### [Manage audiences](https://company-skill.com/p/resend/resend-manage-audiences.md)

## What You Want to Do

You want to add, update, or organize email contacts in Resend—either by syncing from your app/CRM or by using a visual interface—and manage how they’re grouped (segments), what they subscribe to (topics), and how they unsubscribe.

**Typical User Questions**:
- How to add contacts to Resend?
- Can I create contact segments?

## Decision Tree

Pick the best path for your situation:

- **If** you need to sync user data automatically from an application or CRM using code → Use Programmatic Contact Management (go to *resend/resend-contacts*)
- **If** you are managing fewer than 100 contacts manually and prefer clicking over coding → Use Console Audience Management (go to *resend/resend-contacts*)
- **If** you require handling contact lifecycle events like `contact.created` or `contact.updated` via webhooks → Use Programmatic Contact Management (go to *resend/resend-contacts*)
- **Otherwise (default)** → Start with **Console Audience Management** if you lack development resources or are testing small campaigns; otherwise choose **Programmatic Contact Management** for production integrations.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| Programmatic Contact Management | When syncing user data from your application or CRM into Resend automatically. | medium | Yes | Yes | Per-request billing at $0.0001 per API call; 100 requests/minute rate limit | `resend/api/resend-contacts` |
| Console Audience Management | When manually managing small lists, segments, or topics through the dashboard. | low | No | No | Per-request billing at $0.0005 per request; no bulk operations available | `resend/guide/resend-contacts` |

## Path Details

### Path 1: Programmatic Contact Management

**Best For**: When syncing user data from your application or CRM into Resend automatically.

**Brief Description**: The **Resend Contacts & Audience Management API** is a RESTful synchronous HTTP service that supports **CRUD operations** for managing **contacts**, **segments**, **topics**, and deprecated **audiences**. It also enables handling of **webhook events** such as `contact.created`, `contact.updated`, and `contact.deleted`.

**Key technical facts**:
- Billing: Per-request billing model where each API call is charged individually; standard tier priced at 0.0001 per request

**When to Use**:
- Need to sync user data from application or CRM into Resend automatically
- Require programmatic creation, update, or deletion of contacts, segments, or topics
- Need to handle contact lifecycle events via webhooks (contact.created, contact.deleted, contact.updated)
- Building automation or integration that requires SDK or direct REST API access

**When NOT to Use**:
- Only managing small lists manually without code
- Prefer UI-based workflows over API integration
- Do not have ability to handle webhook endpoints or manage API keys securely
- Working with legacy audience structures without plans to migrate to segments

**Known Limitations**:
- Audiences are deprecated in favor of segments; audience endpoints may be removed in future versions
- API rate limit of 100 requests per minute per API key
- Webhook delivery attempts are billed per event sent, including retries up to 3 times
- Does not support asynchronous operations — all API calls follow synchronous request-response pattern

### Path 2: Console Audience Management

**Best For**: When manually managing small contact lists, segments, or topics through the dashboard.

**Brief Description**: The Resend **dashboard** provides **manual management** of contacts, **segments**, **topics**, and **unsubscribe page customization** via **Settings > Unsubscribe Page**. Users can also access best practices through **Documentation > Knowledge Base > Audience Hygiene**.

**Key technical facts**:
- Billing: per_request billing model; standard tier priced at 0.0005 per request

**When to Use**:
- Manually managing small contact lists, segments, or topics through the dashboard
- Customizing unsubscribe page branding (title, logo, colors) via UI
- Accessing audience hygiene best practices without writing code
- User lacks development resources or prefers point-and-click interface

**When NOT to Use**:
- Need to automate contact synchronization from external systems
- Require real-time handling of contact lifecycle events
- Managing large-scale contact databases requiring bulk operations
- Building integrations that depend on API access or SDK usage

**Known Limitations**:
- Cannot remove "Powered by Resend" footer from unsubscribe page unless on Pro plan or higher
- No programmatic or bulk operations available — all actions require manual UI interaction
- Limited to basic audience hygiene guidance rather than automated list cleaning
- Does not support webhook configuration or event handling through the console

## FAQ

Q: Which path should I start with?
A: If you’re prototyping or managing under 100 subscribers without engineering support, start with **Console Audience Management**. For any production system with live user data, use **Programmatic Contact Management**.

Q: What if I need to sync 10,000 contacts daily but chose Console Audience Management?
A: You’ll hit a hard limit—you cannot perform bulk imports or automated syncs in the dashboard, forcing error-prone manual entry or migration later.

Q: What if I’m on the Free plan but used Console Audience Management to customize my unsubscribe page?
A: Your page will display a “Powered by Resend footer” that cannot be removed until you upgrade to a **Pro plan**.

Q: Can I use both paths together?
A: Yes—many teams use the console for initial setup and topic design, then switch to the API for ongoing sync. Just avoid using deprecated **audiences (deprecated)** in new workflows.

Q: What happens if I rely on audience endpoints in the API long-term?
A: Since **audiences (deprecated)** are being phased out in favor of **segments**, your integration may break when Resend removes those endpoints.

Q: Does the Console support webhook setup for bounce handling?
A: Only indirectly—**Documentation > Knowledge Base > Audience Hygiene** mentions webhook setup for bounce/spam notifications, but you must configure them externally; the console itself doesn’t manage **webhook events**.

### [Manage templates](https://company-skill.com/p/resend/resend-manage-templates.md)

## What You Want to Do

You want to create reusable, customizable email templates in Resend—either by writing raw HTML with variables or by building dynamic emails using React components. You may also need to update, publish, or version-control these templates over time.

**Typical User Questions**:
- How to create email templates in Resend?
- Can I use React to build emails?

## Decision Tree

Pick the best path for your situation:

- **If** you need to programmatically create, update, publish, or duplicate templates using HTTP requests → Use **Template Management via API** (go to *resend/resend-templates*)
- **If** you want to build emails using **React**, **JSX**, and **Tailwind CSS** with local preview and hot reloading → Use **React Email Template Development** (go to *resend/resend-template*)
- **Otherwise (default)** → Start with **React Email Template Development** if you're building new, styled, dynamic emails; use **Template Management via API** if you're integrating with backend systems or automating template lifecycle.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| Template Management via API | When managing templates programmatically, including publishing and duplication. | medium | Yes | Yes | Max template size is 1 MB (HTML + text combined) | `resend/api/resend-templates` |
| React Email Template Development | When building dynamic, component-based emails using React and JSX. | high | Yes | Yes | Requires **Full Access scope** API key and local Node.js environment | `resend/guide/resend-template` |

## Path Details

### Path 1: Template Management via API

**Best For**: When managing templates programmatically, including publishing and duplication.

**Brief Description**: This approach uses Resend’s RESTful API at `https://api.resend.com/templates` to create, retrieve, update, delete, list, publish, and duplicate email templates. It supports **template variables**, **versioning**, and requires authentication via `Authorization: Bearer <your_api_key>` using the `RESEND_API_KEY`.

**Key technical facts**:
- Billing: Template management operations (create, update, delete, list, etc.) are free. You are only billed when you send emails using templates.

**When to Use**:
- Need to programmatically manage templates including publishing and duplication
- Require integration with existing codebases or automation pipelines
- Working with dynamic content through template variables

**When NOT to Use**:
- Prefer visual email template authoring without writing code
- Want to use React components and JSX for email development
- Need local preview with hot reloading during template development

**Known Limitations**:
- Maximum template size is 1 MB (HTML + text combined)
- Maximum number of variables per template is 100
- Published templates cannot be edited directly; updates create a new **draft** version that must be republished
- Only HTML is required; text version is auto-generated if omitted

### Path 2: React Email Template Development

**Best For**: When building dynamic, component-based emails using React and JSX.

**Brief Description**: This method uses **React Email** to build emails with **JSX** and **Tailwind CSS**. You initialize a project with `npx create-email@latest`, develop templates in files like `emails/welcome.tsx`, and preview them locally using `npm run email:dev` with **hot reloading**. Templates are uploaded to the **Resend dashboard Templates** section via the **Upload button** in the preview UI.

**Key technical facts**:
- Billing: Only sent emails are billed at ¥0.0001 per email; stored or uploaded templates incur no cost.
- Runtimes: React, JSX, Tailwind CSS

**When to Use**:
- Building dynamic, component-based emails using React and JSX
- Want local preview with hot reloading during development
- Prefer code-based email template workflows with version control
- Need team collaboration on templates through Resend dashboard syncing

**When NOT to Use**:
- Need to programmatically manage templates via API calls
- Don't want to set up a local React development environment
- Prefer direct API integration without CLI tools
- Working with simple HTML templates without React components

**Known Limitations**:
- Cannot edit templates directly in the Resend dashboard; all edits must be made locally and re-uploaded
- Requires Resend API Key with **Full Access scope** (restricted scopes like 'Send Only' will fail)
- Dependent on local development environment with Node.js and package manager
- Must re-upload template after every local change to sync with Resend

## FAQ

Q: Which path should I start with?
A: If you’re building new marketing or transactional emails and comfortable with React, start with **React Email Template Development**. If you’re automating template creation from a backend service or CI/CD pipeline, use **Template Management via API**.

Q: What if I need to edit a published template frequently but used the API path?
A: You’ll need to create a new **draft** version each time and explicitly call `templates/publish`—you cannot edit a **published** template in place.

Q: What if I try to upload a React Email template without **Full Access scope** on my `RESEND_API_KEY`?
A: The upload will fail because the **Upload button** in the preview UI requires permissions beyond "Send Only"—you must grant **Full Access scope** in the Resend dashboard.

Q: Can I use **variables** in React Email templates like in the API path?
A: Yes, but they’re handled differently: in React Email, you pass props to components; in the API path, you define `variables` in the template payload sent to `https://api.resend.com/templates`.

Q: What happens if I build a complex email with Tailwind CSS but choose the API path?
A: You’ll lose the benefits of **hot reloading**, local preview via `npm run email:dev`, and component reuse—you’d have to write all HTML/CSS manually and manage it as a string.

Q: Is there a way to visually edit templates in Resend?
A: No—neither path offers a true visual/WYSIWYG editor. The **Resend dashboard Templates** section only displays uploaded or API-created templates; editing always happens either via code (React) or API calls.

### [Optimize deliverability](https://company-skill.com/p/resend/resend-optimize-deliverability.md)

## What You Want to Do

You want your transactional or marketing emails to reliably land in recipients’ inboxes—not spam folders—and avoid delivery failures like hard bounces or 403 errors. This includes diagnosing existing issues, setting up new domains correctly, or monitoring ongoing performance.

**Typical User Questions**:
- Why are my emails going to spam?
- How to avoid Gmail spam folder?

## Decision Tree

Pick the best path for your situation:

- **If** your emails are already landing in the **spam folder**, showing **403 error code 1010**, or you see **hard bounces** / **spam complaints** in logs → Use **Deliverability Troubleshooting** (go to *resend/resend-deliverability*)
- **If** you're launching a new email system, integrating **Supabase Auth emails**, or need to follow the **Domain and/or IP Warm-up Guide** using **@resend.dev test addresses** → Use **Proactive Deliverability Best Practices** (go to *resend/resend-deliverability*)
- **If** you want to monitor **permanent bounces**, **transient bounces**, **noemail bounces**, or review **suppression reasons** via the **Insights Report panel** → Use **Console Deliverability Monitoring** (go to *resend/resend-sending*)
- **Otherwise (default)** → Start with **Proactive Deliverability Best Practices** if setting up anything new; otherwise use **Console Deliverability Monitoring** for ongoing visibility.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| Deliverability Troubleshooting | When diagnosing specific issues like spam placement, suppression lists, or delivery gaps. | high | No | No | Requires access to DNS for SPF/DKIM/DMARC configuration | `resend/troubleshooting/resend-deliverability` |
| Proactive Deliverability Best Practices | When setting up new domains or integrating with auth systems like Supabase to maximize inbox placement. | medium | No | No | Test addresses are limited to @resend.dev domains | `resend/guide/resend-deliverability` |
| Console Deliverability Monitoring | When using Resend’s dashboard to monitor sender reputation and delivery metrics. | low | No | No | Billing is per-request based on number of emails sent | `resend/guide/resend-sending` |

## Path Details

### Path 1: Deliverability Troubleshooting

**Best For**: When diagnosing specific issues like spam placement, suppression lists, or delivery gaps.

**Brief Description**: This troubleshooting guide helps resolve concrete deliverability problems such as emails ending up in the **spam folder**, **403 error code 1010** (often due to **domain mismatch error**), or entries in the **Suppression List**. It leverages tools like **Deliverability Insights**, **SPF**, **DKIM**, and **DMARC** records to identify root causes.

**Key technical facts**:
- Prerequisites: verified domain in Resend dashboard, access to DNS records for SPF/DKIM/DMARC configuration

**When to Use**:
- User is experiencing specific deliverability symptoms like emails going to spam folders
- User needs to resolve suppression list issues or 403 error code 1010
- User requires detailed root cause analysis for 'delivered but not received' scenarios

**When NOT to Use**:
- User is setting up a new domain and needs proactive best practices
- User wants to monitor ongoing deliverability metrics through a dashboard
- User needs step-by-step console configuration instructions rather than troubleshooting

**Known Limitations**:
- Only addresses specific diagnosed issues rather than providing proactive setup guidance
- Requires manual verification steps through Resend dashboard and external tools like MXToolbox
- Does not provide automated remediation for deliverability issues

### Path 2: Proactive Deliverability Best Practices

**Best For**: When setting up new domains or integrating with auth systems like Supabase to maximize inbox placement.

**Brief Description**: This guide provides step-by-step instructions for initial domain setup in Resend, including navigating **Dashboard > Domains > Add Domain**, configuring authentication via **DMARC Setup Guide**, and optionally disabling tracking using the **Link Tracking toggle** and **Open Tracking toggle**. It also covers creating a **dedicated subdomain** and following the **Domain and/or IP Warm-up Guide** using **@resend.dev test addresses** for safe testing of **Supabase Auth emails**.

**Key technical facts**:
- Prerequisites: Supabase project with Auth enabled, custom domain registered, access to Resend dashboard, understanding of sending volume patterns

**When to Use**:
- User is setting up new domains or integrating with auth systems like Supabase
- User needs to configure dedicated subdomains with tracking disabled
- User requires domain/IP warm-up guidance for establishing sender reputation

**When NOT to Use**:
- User is experiencing specific deliverability issues that need troubleshooting
- User wants to monitor ongoing deliverability metrics through dashboard insights
- User needs to resolve immediate problems like suppression list entries

**Known Limitations**:
- Focuses on initial setup and configuration rather than diagnosing existing problems
- Warm-up guidance requires manual implementation of sending schedules
- Test addresses are limited to @resend.dev domains (blocks @example.com and @test.com)

### Path 3: Console Deliverability Monitoring

**Best For**: When using Resend’s dashboard to monitor sender reputation and delivery metrics.

**Brief Description**: This console-based approach uses **Dashboard > Deliverability Insights**, **Dashboard > Logs > Bounces**, and **Dashboard > Logs > Suppressions** to track delivery health. Users can inspect **permanent bounces**, **transient bounces**, **noemail bounces**, and **suppression reasons**, then act via the **Fix Issues button** in the **Insights Report panel**.

**Key technical facts**:
- Billing: Per-request billing based on the number of emails sent
- Prerequisites: Verified domain, Resend account created, domain ownership confirmed

**When to Use**:
- User wants to monitor ongoing sender reputation and delivery metrics
- User needs to review bounce types and suppression details through dashboard logs
- User requires visibility into deliverability factors through Insights reports

**When NOT to Use**:
- User needs to troubleshoot specific deliverability issues like spam placement
- User is setting up initial domain configuration and authentication
- User requires proactive best practices for new domain setup

**Known Limitations**:
- Monitoring capabilities require a verified domain to access insights
- Suppression management applies across all domains in the user's region
- Topic subscription types cannot be modified after creation

## FAQ

Q: Which path should I start with?
A: If you’re launching a new email system or domain, start with **Proactive Deliverability Best Practices**. If you already have sending activity and suspect issues, begin with **Console Deliverability Monitoring** to assess health before diving into **Deliverability Troubleshooting**.

Q: What if I’m seeing emails in the spam folder but chose Proactive Deliverability Best Practices?
A: You’ll miss critical diagnostic steps—this path doesn’t address existing **spam folder** placement or **403 error code 1010**. You’ll need to switch to **Deliverability Troubleshooting** to investigate **SPF**, **DKIM**, **DMARC**, or **domain mismatch error** issues.

Q: What if I’m setting up a new domain but used Console Deliverability Monitoring instead?
A: You won’t get guidance on essential setup steps like the **Domain and/or IP Warm-up Guide**, configuring **Link Tracking toggle**, or using **@resend.dev test addresses**—leading to poor initial sender reputation and potential **permanent bounces**.

Q: Can I use @example.com addresses for testing during warm-up?
A: No—**@resend.dev test addresses** are the only allowed test domains; **@example.com** and **@test.com** are blocked per Resend policy.

Q: Do I need to verify my domain to see bounce logs?
A: Yes—**Dashboard > Logs > Bounces** and **Dashboard > Deliverability Insights** require a **verified domain** to display data.

Q: Why am I getting a 403 error when sending?
A: This is often **403 error code 1010**, caused by a **domain mismatch error**—your “from” address doesn’t match a verified domain. Check your domain setup in **Dashboard > Domains > Add Domain** and ensure proper **SPF/DKIM** alignment.

Q: Are suppression lists shared across all my domains?
A: Yes—**Suppression List** entries apply across all domains in your region, which can unexpectedly block sends even on newly added domains.

### [Send email](https://company-skill.com/p/resend/resend-send-email.md)

## What You Want to Do

You want to send an email using Resend, whether it's a single transactional message, a bulk campaign, or a notification from a script. The method you choose depends on your environment, audience size, and need for automation.

**Typical User Questions**:
- How to send an email with Resend?
- What are the ways to send emails in Resend?

## Decision Tree

Pick the best path for your situation:

- **If** you are sending emails from application code using parameters like `from`, `to`, and `subject` → Use Programmatic Email Sending (API) (go to *resend/resend-sending*)
- **If** you are performing one-off sends and managing deliverability via UI sections like **Console > Domains > Verify Domain** or **Dashboard > Deliverability Insights** → Use Console-Based Email Sending (go to *resend/resend-sending*)
- **If** you are working in a terminal or shell script and can use the `resend emails send` command with `RESEND_API_KEY` and pipe content via `stdin` → Use Command-Line Email Sending (go to *resend/resend-cli*)
- **If** you are running a one-time or scheduled email campaign to many recipients using the `POST /broadcasts` API with fields like `name`, `content`, `recipients`, and `schedule` → Use Broadcast Campaign Sending (go to *resend/resend-broadcasts*)
- **Otherwise (default)** → Use **Programmatic Email Sending (API)** — it’s the most flexible for transactional use cases and supports webhooks for delivery tracking.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| Programmatic Email Sending (API) | When you need to integrate email sending into your application code or automate workflows. | medium | Yes | Yes | Max 100 recipients per email request; supports `webhooks` for delivery tracking | `resend/api/resend-sending` |
| Console-Based Email Sending | When you prefer a visual interface for one-off or scheduled sends without writing code. | low | No | No | Requires manual navigation through **Dashboard > Logs > Bounces** and **Dashboard > Logs > Suppressions** | `resend/guide/resend-sending` |
| Command-Line Email Sending | When you need to send emails from scripts, CI/CD pipelines, or terminal environments. | low | No | Yes | Uses `resend emails send` with `--json` flag for `machine-readable JSON output` | `resend/cli/resend-cli` |
| Broadcast Campaign Sending | When sending one-time email campaigns to large audiences with tracking needs. | medium | Yes | Yes | Managed via `POST /broadcasts`, `PATCH /broadcasts/{id}`, and `DELETE /broadcasts/{id}` endpoints | `resend/api/resend-broadcasts` |

## Path Details

### Path 1: Programmatic Email Sending (API)

**Best For**: When you need to integrate email sending into your application code or automate workflows.

**Brief Description**: Resend Email Sending API is a RESTful service for sending transactional emails programmatically by making HTTP POST requests to https://api.resend.com/emails with required parameters like `from`, `to`, and `subject`. It supports `webhooks` for delivery tracking and allows attachments up to 25MB each.

**Key technical facts**:
- Billing: Per-request billing — you pay for each email sent and each webhook event delivered. Standard emails cost ¥0.0001 per email.
- Auth method: Bearer Token via Authorization header

**When to Use**:
- Need to integrate email sending directly into application code
- Require automation of transactional emails
- Need fine-grained control over email parameters
- Sending emails with attachments programmatically
- Implementing webhook handling for delivery tracking

**When NOT to Use**:
- User prefers visual interface without coding
- One-off email sends without automation needs
- Sending from terminal/script environments where CLI is preferred
- Running large marketing campaigns better suited for Broadcast API

**Known Limitations**:
- Max 100 recipients per email request
- Max 10 attachments per email, each max 25MB
- HTML/text content max length 6000 chars
- Subject max length 255 characters
- Rate limit of 100 requests per second per API key
- Requires code implementation in application

### Path 2: Console-Based Email Sending

**Best For**: When you prefer a visual interface for one-off or scheduled sends without writing code.

**Brief Description**: Resend Console-Based Email Sending is a visual dashboard interface for managing email sending operations including domain verification, deliverability insights, bounce management, and topic creation without writing code. Key UI paths include **Console > Domains > Verify Domain**, **Dashboard > Deliverability Insights**, and **Dashboard > Email Management > Topics**.

**Key technical facts**:
- Billing: Per-request billing based on the number of emails sent. Standard emails cost ¥0.0001 per email.
- Auth method: Console SSO

**When to Use**:
- Performing one-off email configuration tasks
- Managing domain verification through visual DNS record setup
- Monitoring deliverability insights through dashboard
- Handling bounce and suppression logs visually
- Setting up multi-tenant configurations through **Dashboard > API Keys**

**When NOT to Use**:
- Need to send emails programmatically from application code
- Require automation-friendly email sending
- Working in terminal/script environments
- Sending large-scale email campaigns requiring API integration

**Known Limitations**:
- Not suitable for automated workflows or programmatic integration
- Limited to manual operations through UI
- Cannot be used in CI/CD pipelines or scripts
- No direct API access for custom implementations
- Requires manual navigation through dashboard sections

### Path 3: Command-Line Email Sending

**Best For**: When you need to send emails from scripts, CI/CD pipelines, or terminal environments.

**Brief Description**: Resend CLI is a command-line tool that enables sending emails directly from terminal environments using the `resend emails send` command with email body piped via `stdin` and authentication via `RESEND_API_KEY` environment variable. It supports `--json` for `machine-readable JSON output` and can be installed via `npx skills add resend/resend-cli`.

**Key technical facts**:
- Auth method: `RESEND_API_KEY` environment variable
- Prerequisites: Node.js and npm/npx installed

**When to Use**:
- Sending emails from shell scripts or terminal environments
- CI/CD pipeline integration for notifications
- AI agent workflows requiring non-interactive email sending
- Quick one-off sends from command line
- Need machine-readable JSON output for parsing

**When NOT to Use**:
- Complex email templates requiring full API parameters
- Large-scale email campaigns better handled by Broadcast API
- Visual configuration preferred over command line
- Applications requiring deep integration with email sending logic

**Known Limitations**:
- Sends one email per invocation (no batch sending in single command)
- Requires Node.js and npm/npx for installation
- Authentication limited to environment variable method
- Limited parameter options compared to full API
- No built-in scheduling capabilities

### Path 4: Broadcast Campaign Sending

**Best For**: When sending one-time email campaigns to large audiences with tracking needs.

**Brief Description**: Resend Broadcasts Management API is a RESTful service for creating, managing, and sending one-time or scheduled email campaigns to multiple recipients via HTTP requests to https://api.resend.com/broadcasts endpoints. It uses `Authorization: Bearer` and supports fields like `name`, `content`, `recipients`, `schedule`, and `subject`.

**Key technical facts**:
- Auth method: `Authorization: Bearer`

**When to Use**:
- Sending one-time email campaigns to large audiences
- Need campaign analytics and tracking
- Scheduling future email sends programmatically
- Managing broadcast lifecycle (`POST /broadcasts`, `PATCH /broadcasts/{id}`, `DELETE /broadcasts/{id}`)
- Bulk communication requiring structured campaign management

**When NOT to Use**:
- Transactional email sending requiring immediate delivery
- Simple one-off emails better handled by basic Send Email API
- Non-programmatic use cases preferring console interface
- Terminal/script environments where CLI is more appropriate

**Known Limitations**:
- Only drafts or scheduled broadcasts can be deleted (sent broadcasts cannot be deleted)
- No specific mention of large recipient list handling (>10k)
- Requires code implementation for integration
- Limited to one-time or scheduled campaigns (not real-time transactional)
- No unsubscribe link automatically included (must be added manually for marketing compliance)

## FAQ

Q: Which path should I start with?
A: Start with **Programmatic Email Sending (API)** if you're building an app or need automation. It supports `from`, `to`, `subject`, and `webhooks`, and scales to most transactional use cases.

Q: What if I need to send 500 personalized emails but used the standard Send Email API?
A: You’ll hit the **100 recipients per email request** limit and must make 5 separate API calls — consider Broadcast API for true bulk sends.

Q: What if I’m in a CI/CD pipeline but chose Console-Based Email Sending?
A: You’ll be unable to send emails because the Console requires manual interaction and **cannot be used in CI/CD pipelines or scripts**.

Q: Can I use the CLI to send HTML emails with attachments?
A: The CLI has **limited parameter options compared to the full API** and doesn’t support attachments — use the Programmatic API instead.

Q: Do I need to verify my domain for all paths?
A: Yes — all paths require a **verified domain**, which you can set up via **Console > Domains > Verify Domain** regardless of your sending method.

Q: Does the Broadcast API automatically include unsubscribe links?
A: No — **no unsubscribe link is automatically included**, so you must add one manually to comply with marketing regulations.

Q: Can I delete a broadcast after it’s been sent?
A: No — **only drafts or scheduled broadcasts can be deleted**; sent broadcasts are immutable per the `DELETE /broadcasts/{id}` limitation.

### [Verify domain](https://company-skill.com/p/resend/resend-verify-domain.md)

## What You Want to Do

You need to authenticate your domain for sending emails through Resend by configuring DNS records (SPF, DKIM, DMARC) and confirming ownership. This ensures deliverability and prevents spoofing.

**Typical User Questions**:
- How to verify my domain in Resend?
- Why is my domain verification failing?

## Decision Tree

- **If** you're building automated onboarding for customers using infrastructure-as-code or CI/CD pipelines → Use API Domain Verification (go to *resend/resend-domains*)
- **If** you're manually setting up your own domain and prefer a visual interface with guided steps → Use Console Domain Verification (go to *resend/resend-domains*)
- **If** your domain fails to verify, shows Error 1010, or has MX priority conflicts with Google Workspace → Use Domain Verification Troubleshooting (go to *resend/resend-delivery*)
- **Otherwise (default)** → Start with Console Domain Verification — it’s the safest for first-time setup with built-in copy buttons and region selection.

## Path Comparison

| Path | Best For | Complexity | Code Required | Automation | Key Fact | Detail Skill |
|------|----------|------------|---------------|------------|----------|-------------|
| API Domain Verification | Automating domain setup in infrastructure-as-code or multi-tenant systems | medium | Yes | Yes | Synchronous REST API at https://api.resend.com/v1/domains with per-request billing | `resend/api/resend-domains` |
| Console Domain Verification | Manually setting up a domain through Resend's dashboard with guided steps | low | No | No | Free tier includes 1,000 emails/month; verification may take minutes to 72 hours due to DNS propagation delay | `resend/guide/resend-domains` |
| Domain Verification Troubleshooting | Encountering DNS conflicts or verification failures and needing resolution steps | medium | No | No | Verification delays beyond 1 hour typically indicate configuration errors, not propagation | `resend/troubleshooting/resend-delivery` |

## Path Details

### Path 1: API Domain Verification

**Best For**: When automating domain setup in infrastructure-as-code or multi-tenant systems.

**Brief Description**: Resend Domains Management API is a synchronous REST service for creating, retrieving, updating, deleting, and verifying sending domains via HTTP requests to `https://api.resend.com/v1/domains`. It supports programmatic lifecycle management and emits a `domain.updated webhook` for integration with custom applications. You must handle DNS records (including `resend._domainkey` for DKIM and `_dmarc host` for DMARC) externally.

**Key technical facts**:
- Billing: Per-request billing for webhook deliveries at ¥0.0001 per request; standard Resend API rate limits apply (typically 100 QPS)
- Auth method: API key authentication via Authorization header: Bearer <your_api_key>
- Regions available: cn-hangzhou, cn-hongkong, sa-east-1, ap-northeast-1
- Prerequisites: Valid domain name in correct format, API key stored securely, Environment variable RESEND_API_KEY set

**When to Use**:
- Automating domain setup in infrastructure-as-code pipelines
- Building multi-tenant systems requiring programmatic domain lifecycle management
- Integrating domain verification into CI/CD workflows
- Handling domain update events via webhooks in custom applications

**When NOT to Use**:
- Manually setting up a single domain without coding resources
- Users unfamiliar with REST API concepts or curl/HTTP clients
- Situations requiring guided UI steps for DNS record configuration
- Troubleshooting DNS conflicts or verification failures without diagnostic tools

**Known Limitations**:
- No polling or async task tracking supported—all operations are synchronous with immediate JSON responses
- Deleted domains cannot be recovered—must recreate from scratch
- Webhook delivery limited to 100 requests per minute per endpoint
- Domain region cannot be changed after creation

### Path 2: Console Domain Verification

**Best For**: When manually setting up a domain through Resend's dashboard with guided steps.

**Brief Description**: The Resend Domains Management Console Guide provides step-by-step UI instructions via the Domains page. You click the **Add Domain button**, select a region using the **Region dropdown**, and configure email authentication through dedicated sections like the **BIMI section** and **DMARC section**. Built-in **Copy button (for DNS records)** helps paste exact values for SPF, DKIM (`resend._domainkey`), and DMARC (`_dmarc host`). After setup, you click **Verify DNS Records button** to confirm.

**Key technical facts**:
- Billing: Per-email pricing at ¥0.0001 per email (sent or received); 1,000 emails/month free tier
- Auth method: Console login with admin privileges
- Regions available: cn-hangzhou, cn-hongkong, sa-east-1, ap-northeast-1
- Prerequisites: Admin privileges on Resend account, Access to DNS provider (e.g., Cloudflare or DreamHost), Domain ownership confirmed with DNS provider

**When to Use**:
- Manually setting up a domain through guided UI steps
- Users preferring visual interfaces over command-line/API interactions
- Configuring BIMI branding or DMARC policies through dedicated console sections
- Quickly copying DNS record values with built-in copy buttons

**When NOT to Use**:
- Automating domain setup across multiple environments
- Integrating domain verification into code-based workflows
- Handling domain lifecycle events programmatically
- Situations requiring immediate verification feedback without waiting for DNS propagation

**Known Limitations**:
- Region selection is fixed at creation time and cannot be modified later
- Enabling **Receiving toggle** on root domains may break existing email services like Gmail Workspace
- Manual DNS setup requires exact record copying—extra dots/spaces cause verification failures
- Verification may take minutes to 72 hours depending on **DNS propagation delay**

### Path 3: Domain Verification Troubleshooting

**Best For**: When encountering DNS conflicts or verification failures and needing resolution steps.

**Brief Description**: This guide diagnoses issues like **Error 1010**, failed verifications, or email landing in spam despite a "verified" domain. It uses CLI tools like `dig TXT resend-verify.example.com +short` and `dig MX example.com +short` to validate DNS propagation. It explains how **MX priority conflict** with providers like Google Workspace requires **subdomain isolation**, and how missing **SPF include:resend.email** or incorrect **resend._domainkey** records cause authentication failures visible in the **Authentication-Results** header.

**Key technical facts**:
- Prerequisites: Verified domain with DNS records configured, Command-line access for DNS validation (dig/nslookup), Understanding of SPF/DKIM/DMARC concepts

**When to Use**:
- Encountering 'Domain not verifying' errors after DNS record setup
- Diagnosing MX record conflicts with existing email providers like Google Workspace
- Emails consistently landing in spam folders despite verified domains
- Validating DNS record propagation using public resolvers like 8.8.8.8

**When NOT to Use**:
- Initial domain setup without prior verification attempts
- Automating domain verification in production systems
- Situations requiring immediate resolution without diagnostic steps
- Users unfamiliar with DNS concepts like TXT records or MX priorities

**Known Limitations**:
- Does not provide automated fixes—requires manual DNS record correction
- Verification delays beyond 1 hour typically indicate configuration errors rather than propagation issues
- MX record conflicts require architectural changes (**subdomain isolation**) rather than simple toggles
- Spam folder placement requires reputation warm-up over 2–4 weeks with gradual volume increases

## FAQ

Q: Which path should I start with?
A: If you’re setting up your own domain for the first time, start with Console Domain Verification. It provides visual guidance, copy buttons for DNS records, and clear sections for **BIMI**, **DMARC**, and the **Receiving toggle**.

Q: What if I’m building a SaaS product that auto-provisions customer domains but chose Console Domain Verification?
A: You’ll hit a dead end — the Console requires manual clicks and has no automation hooks. You won’t be able to scale beyond a few domains, and you can’t trigger setup from code.

Q: What if my domain uses Cloudflare with “Proxied” DNS status but I used Console Domain Verification?
A: Verification will likely fail because Resend requires **DNS Only proxy status** for TXT/MX records. The Console doesn’t warn about this — you’ll see persistent failures until you switch to DNS-only mode.

Q: Can I use API Domain Verification to fix an already-failing domain?
A: No — the API only creates or updates domains; it doesn’t diagnose why DNS records aren’t propagating or why **Error 1010** occurs. You’d still need the Troubleshooting path to run `dig MX` and validate records.

Q: Why does my verified domain still send emails to spam?
A: Verification confirms ownership but not sender reputation. Without proper **DMARC p=quarantine** policy, gradual volume ramp-up, and correct **SPF include:resend.email**, inbox placement suffers — this is covered in Troubleshooting, not initial setup paths.

Q: What happens if I enable the **Receiving toggle** on my root domain (e.g., example.com) in the Console?
A: It may break existing email services like Google Workspace because Resend adds MX records that conflict with your current provider — use **subdomain isolation** (e.g., mail.example.com) instead, as advised in Troubleshooting.

Q: Do I need to implement **webhook signature verification** when using the API?
A: Yes — if you subscribe to the **domain.updated webhook**, you must verify signatures to prevent spoofed events, though this isn’t required for basic domain creation.


## Frequently asked questions

### Should I use the API or the console?

Use the **API** for programmatic sending, automation, and integration into apps. Use the **console** for setup, monitoring, testing, and one-off operations like creating a broadcast.

### How do I get started sending emails?

First, [verify a domain](https://resend.com/domains). Then, either use the [API](https://resend.com/docs/send-email) with your API key or send via the [console](https://resend.com/emails).

### Why are my emails going to spam?

Check domain authentication (DKIM/SPF/DMARC), warm up new domains gradually, avoid spammy content, and monitor suppression lists. See deliverability best practices in the guide skill.

### Can I manage contacts via code?

Yes—use the Contacts API (`resend-contacts` skill) to create, update, segment, and sync contacts programmatically.

### How do I debug a failed email send?

Check API response errors, review [logs](https://resend.com/logs), verify domain status, and consult troubleshooting guides for 403 errors, suppressions, or DNS issues.

### How do I receive and process real-time email events?

You can receive and process real-time email events by configuring webhooks to track opens, clicks, bounces, and other notifications. You can set up and secure these webhooks via the API or manage and replay deliveries directly in the console.

### How do I manage contacts, segments, and subscription topics?

You can manage contacts, segments, and subscription topics by organizing your audience through the dashboard or programmatically via the API. This enables you to handle properties, topics, and audiences for targeted campaigns.

### How do I create and manage email templates?

You can create and manage email templates by building reusable, dynamic content through the API or the console. The dashboard supports building with React Email and JSX, while the API allows you to publish and manage templates programmatically.

### How do I improve email deliverability and inbox placement?

You can improve email deliverability and inbox placement by warming up domains, testing delivery, and following provider guidelines to optimize sender reputation. You can also troubleshoot and resolve issues like spam placement, suppression lists, and tracking errors to avoid the spam folder.

## Cross-product integrations

- [Auth email delivery troubleshooting](https://company-skill.com/p/_combos/auth-email-delivery-troubleshooting-976ab1.md) (clerk)
- [Bailian RAG + ES Chatbot with EventBridge Alerts](https://company-skill.com/p/_combos/bailian-rag-es-chatbot-with-eventbridge-alerts-873dcb.md) (eb + es + bailian + dataworks + ess)
- [Batch Pipeline with Closed-Loop Multi-Channel Notification](https://company-skill.com/p/_combos/batch-pipeline-with-closed-loop-multi-channel-no-ec172e.md) (eb + alinux + ecs + supabase + ess)
- [Bidirectional DingTalk-Lark ECS Provisioning Loop](https://company-skill.com/p/_combos/bidirectional-dingtalk-lark-ecs-provisioning-loo-9c34b9.md) (eb + ecs + alinux + supabase + dataworks)
- [CI/CD Terraform Full-Stack with Security Hardening](https://company-skill.com/p/_combos/ci-cd-terraform-full-stack-with-security-hardeni-a12154.md) (ecs + terraform + alinux + oss + rds)
- [Closed-Loop Infrastructure Alert with Delivery Verification](https://company-skill.com/p/_combos/closed-loop-infrastructure-alert-with-delivery-v-50872d.md) (twilio + dataworks + eb + ess + rds)
- [Closed-Loop Multi-Channel Notification Pipeline](https://company-skill.com/p/_combos/closed-loop-multi-channel-notification-pipeline-b18bac.md) (eb + twilio + ecs + rds + dataworks)
- [Cloud DB Migration to Full-Stack Observability Platform](https://company-skill.com/p/_combos/cloud-db-migration-to-full-stack-observability-p-0653ab.md) (eb + idaas + gitbook + supabase + rds)

## Use with an AI agent

```bash
curl -s https://company-skill.com/api/route \
  -H 'Content-Type: application/json' \
  -d '{"query": "...", "product": "resend"}'
```

MCP server: https://company-skill.com/api/mcp/resend.py

---
Machine-readable: https://company-skill.com/llms.txt · https://company-skill.com/sitemap.xml