New to Claude Skills? Learn how to install them →

Get Claude Skills
resend on GitHub

React Email

Free

Build and send HTML emails with React components.

by resend19.6k stars on resend/react-email
2 views
Updated Aug 10, 2026
Get this skill

Free · Opens the source repo

What React Email does

React Email is a powerful tool designed for developers looking to create and manage HTML email templates using React components. This skill offers a modern, component-based approach that ensures compatibility across all major email clients. By leveraging the flexibility of React, developers can build visually appealing emails while maintaining clean and manageable code. The skill provides a seamless integration with the Resend service for sending emails, making it a comprehensive solution for email development.

The installation process is straightforward, allowing users to scaffold a new project or add the skill to an existing one with minimal effort. Once set up, developers can utilize a local development server to preview their email templates in real-time, which significantly speeds up the design and iteration process. The skill supports Tailwind CSS for styling, enabling developers to create responsive and aesthetically pleasing emails without the hassle of inline styles.

In addition to basic email templates, React Email supports various types of emails, including welcome messages, password resets, notifications, and newsletters. The skill includes essential components such as headings, buttons, and images, all optimized for email delivery. Furthermore, it emphasizes best practices for email development, such as avoiding unsupported features in email clients and ensuring that templates are valid and functional.

This skill is particularly suitable for developers and designers who are familiar with React and are looking to streamline their email development workflow. By utilizing React Email, they can focus on creating engaging content while the skill handles the complexities of email rendering and sending.

When to use it

Use this skill when building HTML email templates for various purposes, such as transactional emails or newsletters, especially if you prefer a component-based approach with React.

When not to use it

This skill may not be suitable for users who are not familiar with React or those looking for a purely visual email design tool without coding.

What you can build with it

Creating a Welcome Email

Use React Email to design a welcome email template that greets new users and provides them with important information.

Transactional Email Notifications

Build and send transactional emails like order confirmations or password resets using the provided components.

Newsletter Design

Leverage the visual editor to create engaging newsletters that can be easily styled and sent to your subscribers.

How to install React Email

View source

1. Install with the skills CLI

npx skills add resend/react-email/react-email --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by resend

React Email

Build and send HTML emails using React components. A modern, component-based approach to email development that works across all major email clients.

Installation

npm i react-email

Or scaffold a new project:

npx create-email@latest
cd react-email-starter
npm install
npm run dev

This works with any package manager (npm, yarn, pnpm, bun) — substitute accordingly.

The dev server runs at localhost:3000 with a preview interface for templates in the emails folder.

Adding to an Existing Project

Install the packages and add a script to your package.json:

{
  "scripts": {
    "email": "email dev --dir emails --port 3000"
  }
}

Make sure the path to the emails folder is relative to the base project directory. Ensure tsconfig.json includes proper support for JSX.

Basic Email Template

Create an email component with proper structure using the Tailwind component for styling:

import {
  Html,
  Head,
  Preview,
  Body,
  Container,
  Heading,
  Text,
  Button,
  Tailwind,
  pixelBasedPreset
} from 'react-email';

interface WelcomeEmailProps {
  name: string;
  verificationUrl: string;
}

export default function WelcomeEmail({ name, verificationUrl }: WelcomeEmailProps) {
  return (
    <Html lang="en">
      <Tailwind
        config={{
          presets: [pixelBasedPreset],
          theme: {
            extend: {
              colors: {
                brand: '#007bff',
              },
            },
          },
        }}
      >
        <Head />
        <Body className="bg-gray-100 font-sans">
          <Preview>Welcome - Verify your email</Preview>
          <Container className="max-w-xl mx-auto p-5">
            <Heading className="text-2xl text-gray-800">
              Welcome!
            </Heading>
            <Text className="text-base text-gray-800">
              Hi {name}, thanks for signing up!
            </Text>
            <Button
              href={verificationUrl}
              className="bg-brand text-white px-5 py-3 rounded block text-center no-underline box-border"
            >
              Verify Email
            </Button>
          </Container>
        </Body>
      </Tailwind>
    </Html>
  );
}

// Preview props for testing
WelcomeEmail.PreviewProps = {
  name: 'John Doe',
  verificationUrl: 'https://example.com/verify/abc123'
} satisfies WelcomeEmailProps;

export { WelcomeEmail };

Behavioral Guidelines

  • When iterating over the code, only update what the user asked for. Keep the rest intact.
  • If the user asks to use media queries, inform them that most email clients don't support them and suggest a different approach.
  • Never use template variables (like {{name}}) directly in TypeScript code. Instead, reference the underlying properties directly. If the user explicitly asks for {{variableName}}, place the mustache string only in PreviewProps, never in the component JSX:
const EmailTemplate = (props) => {
  return (
    <h1>Hello, {props.variableName}!</h1>
  );
}

EmailTemplate.PreviewProps = {
  variableName: "{{variableName}}",
};

export default EmailTemplate;
  • Never write the {{variableName}} pattern directly in the component structure. If the user insists, explain that this would make the template invalid.

Essential Components

See references/COMPONENTS.md for complete component documentation.

Core Structure:

  • Html - Root wrapper with lang attribute
  • Head - Meta elements, styles, fonts
  • Body - Main content wrapper
  • Container - Outermost centering wrapper (has built-in max-width: 37.5em). Use only once per email.
  • Section - Interior content blocks (no built-in max-width). Use for grouping content inside Container.
  • Row & Column - Multi-column layouts
  • Tailwind - Enables Tailwind CSS utility classes

Content:

  • Preview - Inbox preview text, always first inside <Body>
  • Heading - h1-h6 headings
  • Text - Paragraphs
  • Button - Styled link buttons (always include box-border)
  • Link - Hyperlinks
  • Img - Images (see Static Files section below)
  • Hr - Horizontal dividers

Specialized:

  • CodeBlock - Syntax-highlighted code
  • CodeInline - Inline code
  • Markdown - Render markdown
  • Font - Custom web fonts

Before Writing Code

When a user requests an email template, ask clarifying questions FIRST if they haven't provided:

  1. Brand colors - Ask for primary brand color (hex code like #007bff)
  2. Logo - Ask if they have a logo file and its format (PNG/JPG only - warn if SVG/WEBP)
  3. Style preference - Professional, casual, or minimal tone
  4. Production URL - Where will static assets be hosted in production?

Static Files and Images

Directory Structure

Local images must be placed in the static folder inside your emails directory:

project/
├── emails/
│   ├── welcome.tsx
│   └── static/           <-- Images go here
│       └── logo.png

Dev vs Production URLs

Use this pattern for images that work in both dev preview and production:

const baseURL = process.env.NODE_ENV === "production"
  ? "https://cdn.example.com"  // User's production CDN
  : "";

export default function Email() {
  return (
    <Img
      src={`${baseURL}/static/logo.png`}
      alt="Logo"
      width="150"
      height="50"
    />
  );
}

How it works:

  • Development: baseURL is empty, so URL is /static/logo.png - served by React Email's dev server
  • Production: baseURL is the CDN domain, so URL is https://cdn.example.com/static/logo.png

Important: Always ask the user for their production hosting URL. Do not hardcode localhost:3000.

Styling

See references/STYLING.md for comprehensive styling documentation including typography, layout patterns, dark mode, and brand consistency.

Key Rules

  • Use Tailwind with pixelBasedPreset (email clients don't support rem). Import pixelBasedPreset from react-email.
  • Never use flexbox or grid — use Row/Column components or tables for layouts.
  • Avoid CSS/Tailwind media queries (sm:, md:, lg:, xl:) — limited email client support.
  • Never use theme selectors (dark:, light:) — not supported.
  • Never use SVG or WEBP images — warn users about rendering issues.
  • Always specify border type (border-solid, border-dashed, etc.) — email clients don't inherit it.
  • For single-side borders, reset others first (border-none border-l border-solid).

Required Classes

ComponentRequired ClassWhy
Buttonbox-borderPrevents padding from overflowing the button width
Hr / any borderborder-solid (or border-dashed, etc.)Email clients don't inherit border type
Single-side bordersborder-none + the sideResets default borders on other sides

Structure Notes

  • Always define <Head /> inside <Tailwind> when using Tailwind CSS
  • <Preview> should always be the first element inside <Body>
  • Only include props in PreviewProps that the component actually uses
  • Use fixed width/height for known-size elements (logos, icons); responsive sizing (w-full, h-auto) for content images

Rendering

Convert to HTML

import { render } from 'react-email';
import { WelcomeEmail } from './emails/welcome';

const html = await render(
  <WelcomeEmail name="John" verificationUrl="https://example.com/verify" />
);

Convert to Plain Text

const text = await render(<WelcomeEmail name="John" verificationUrl="https://example.com/verify" />, { plainText: true });

Sending

React Email supports sending with any email service provider. See references/SENDING.md for complete sending documentation including Resend, Nodemailer, and SendGrid examples.

Quick example using the Resend SDK:

import { Resend } from 'resend';
import { WelcomeEmail } from './emails/welcome';

const resend = new Resend(process.env.RESEND_API_KEY);

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['user@example.com'],
  subject: 'Welcome to Acme',
  react: <WelcomeEmail name="John" verificationUrl="https://example.com/verify" />
});

The Resend Node SDK automatically handles both HTML and plain-text rendering.

CLI Commands

The react-email package provides a CLI accessible via the email command:

CommandDescription
email dev --dir <path> --port <port>Start the preview development server (default: ./emails, port 3000)
email build --dir <path>Build the preview app for production deployment
email startRun the built preview app
email export --outDir <path> --pretty --plainText --dir <path>Export templates to static HTML files
email resend setupConnect the CLI to your Resend account via API key
email resend resetRemove the stored Resend API key

Internationalization

See references/I18N.md for complete i18n documentation. React Email supports three libraries: next-intl, react-i18next, and react-intl.

Email Editor

React Email includes a visual editor (@react-email/editor) that can be embedded in your app. It's built on TipTap/ProseMirror and produces email-ready HTML.

See references/EDITOR.md for complete documentation including:

  • EmailEditor — batteries-included component with bubble menus, slash commands, and theming
  • StarterKit — 35+ email-aware extensions (headings, lists, tables, columns, buttons, etc.)
  • Inspector — contextual sidebar for editing styles
  • EmailTheming — built-in themes (basic, minimal) with customizable CSS properties
  • composeReactEmail — export editor content to email-ready HTML and plain text
  • Custom extensions via EmailNode and EmailMark

Quick example:

import { EmailEditor, type EmailEditorRef } from '@react-email/editor';
import '@react-email/editor/themes/default.css';
import { useRef } from 'react';

export function MyEditor() {
  const ref = useRef<EmailEditorRef>(null);

  return (
    <EmailEditor
      ref={ref}
      content="<p>Start typing...</p>"
      theme="basic"
    />
  );
}

Common Patterns

See references/PATTERNS.md for complete examples including:

  • Password reset emails
  • Order confirmations with product lists
  • Notification emails with code blocks
  • Multi-column layouts
  • Team invitation emails

Email Best Practices

  1. Test across email clients - Gmail, Outlook, Apple Mail, Yahoo Mail
  2. Keep it responsive - Max-width around 600px, test on mobile
  3. Use absolute image URLs - Host on reliable CDN
  4. Write meaningful alt text - Describe purpose and details for content images; use alt="" for decorative images (spacers, dividers, background flourishes). React Email's <Img> defaults to alt="".
  5. Provide plain text version - Required for accessibility
  6. Keep file size under 102KB - Gmail clips larger emails
  7. Add proper TypeScript types - Define interfaces for all email props
  8. Include preview props - Add .PreviewProps for development testing
  9. Use verified domains - For production from addresses

Accessibility

React Email handles the structural defaults; the rest is content.

What React Email gives you for free:

  • <Html> sets lang and dir (defaults: lang="en" dir="ltr" — override per locale)
  • <Img> defaults to alt="" so decorative images are skipped by screen readers
  • <Markdown> renders layout tables with role="presentation"
  • <Preview> also emits a <title> tag

Upgrade with npm install react-email@latest to get these defaults.

What you still have to do (content choices):

  • Open with a single <Heading as="h1">, nest subheadings in order, never skip levels (very short SMS-style emails may skip the heading entirely)
  • Set descriptive alt on meaningful images; pass an explicit alt="" on decorative images — never omit the attribute
  • Linked images are never decorative. When an <Img> is inside a <Link> or <Button>, the alt must describe where the link goes — alt="" on a linked image leaves the link with no accessible name
  • Write link text that describes the destination (<Button>Read the report</Button>, not click here)
  • Hit 4.5:1 text contrast (WCAG AA); preview in dark mode
  • For layout tables you build by hand (outside <Markdown>), add role="presentation"
  • For non-English emails, pass the locale: <Html lang={locale} dir={isRTL ? 'rtl' : 'ltr'}> (see I18N.md)

For the full rule set, severity ranking, and authoring checklist, see the accessibility reference in the email-best-practices skill.

Additional Resources

Frequently asked questions about React Email

Similar skills

Playwright Component Testing

Test React and Vue components in isolation with Playwright.

Fluent UI Blazor

Integrate Fluent UI components in Blazor applications effortlessly.

Build MCP App

Create interactive UI widgets for MCP servers.

Web Design Reviewer

Identify and fix design issues in websites efficiently.

Markstream Install

Seamlessly integrate Markstream for Markdown rendering.

GSAP & Framer Scroll Animation

Create advanced scroll animations effortlessly.