Email body here
', }, { 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: 'AcmeYour order has shipped!
', }, { from: 'AcmeYour order is confirmed!
', }, ], { idempotencyKey: `batch-orders/${batchId}` }, ); if (error) { console.error('Batch failed:', error.message); return; } console.log( 'Sent:', data.map((e) => e.id), ); ```Hello {{{contact.first_name|there}}}!
", "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" } ```it works!
', }, ]); ``` ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->batch->send([ [ 'from' => 'Acmeit works!
', ] ]); ``` ```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": "Acmeit works!
", } ] resend.Batch.send(params) ``` ```rb Ruby theme={"theme":{"light":"github-light","dark":"vesper"}} require "resend" Resend.api_key = 're_xxxxxxxxx' params = [ { "from": "Acmeit works!
", } ] Resend::Batch.send(params) ``` ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}} package main import ( "fmt" "os" "github.com/resend/resend-go/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") var batchEmails = []*resend.SendEmailRequest{ { From: "Acmeit works!
", }, } 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( "Acmeit works!
"), ]; let _emails = resend.batch.send(emails).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 firstEmail = CreateEmailOptions.builder() .from("Acmeit works!
") .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 = "Acmeit works!
", }; var mail2 = new EmailMessage() { From = "Acmeit works!
", }; 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": "Acmeit works!
" } ]' ``` ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails batch --file ./path/to/emails.json ```it works!
', }); ``` ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->emails->send([ 'from' => 'Acmeit works!
' ]); ``` ```python Python theme={"theme":{"light":"github-light","dark":"vesper"}} import resend resend.api_key = "re_xxxxxxxxx" params: resend.Emails.SendParams = { "from": "Acmeit works!
" } 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": "Acmeit works!
" } 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/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") params := &resend.SendEmailRequest{ From: "Acmeit works!
" } 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 = "Acmeit works!
"; 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("Acmeit works!
") .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 = "Acmeit works!
", } ); 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": "Acmeit works!
" }' ``` ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails send \ --from "Acmeit works!
" ```Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
', variables: [ { key: 'PRODUCT', type: 'string', fallbackValue: 'item', }, { key: 'PRICE', type: 'number', fallbackValue: 25, } ], }); // Or create and publish a template in one step await resend.templates.create({ ... }).publish(); ``` ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->templates->create([ 'name' => 'order-confirmation', 'html' => 'Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
', '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": "Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
", "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: "Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 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/v3" ) func main() { client := resend.NewClient("re_xxxxxxxxx") client.Templates.CreateWithContext(context.TODO(), &resend.CreateTemplateRequest{ Name: "order-confirmation", Html: "Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 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 = "Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
"; 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.*; public class Main { public static void main(String[] args) { Resend resend = new Resend("re_xxxxxxxxx"); CreateTemplateOptions params = CreateTemplateOptions.builder() .name("order-confirmation") .html("Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
") .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 ListName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", "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 "Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
" \ --var PRODUCT:string:item \ --var PRICE:number:25 ```Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
', }, ); ``` ```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' => 'Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
', ]); ``` ```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": "Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
", }) ``` ```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: "Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
" }) ``` ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}} package main import ( "context" "github.com/resend/resend-go/v3" ) func main() { client := resend.NewClient("re_xxxxxxxxx") client.Templates.UpdateWithContext(context.TODO(), "34a080c9-b17d-4187-ad80-5af20266e535", &resend.UpdateTemplateRequest{ Name: "order-confirmation", Html: "Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
", }) } ``` ```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 = "Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
"; 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.*; public class Main { public static void main(String[] args) { Resend resend = new Resend("re_xxxxxxxxx"); UpdateTemplateOptions params = UpdateTemplateOptions.builder() .name("order-confirmation") .html("Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
") .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 = "Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
", } ); ``` ```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": "Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
" }' ``` ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}} resend templates update 34a080c9-b17d-4187-ad80-5af20266e535 \ --name order-confirmation \ --html "Total: {{{PRICE}}}
Name: {{{PRODUCT}}}
" ```it works!
", "scheduled_at": "in 5 min" } ] ``` **Other email commands** ```bash theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails list # List sent emails resend emails getThanks for the payment
', 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' => 'AcmeThanks for the payment
', '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": "AcmeThanks for the payment
", "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": "AcmeThanks for the payment
", "attachments": [ { "path": "https://resend.com/static/sample/invoice.pdf", "filename": 'invoice.pdf', } ] } Resend::Emails.send(params) ``` ```go Go {12-13} theme={"theme":{"light":"github-light","dark":"vesper"}} import ( "fmt" "github.com/resend/resend-go/v3" ) 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: "AcmeThanks for the payment
", 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 = "AcmeThanks for the payment
") .with_attachment(CreateAttachment::from_path(path).with_filename(filename)); let _email = resend.emails.send(email).await?; Ok(()) } ``` ```java Java {8-9} 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"); Attachment att = Attachment.builder() .path("https://resend.com/static/sample/invoice.pdf") .fileName("invoice.pdf") .build(); CreateEmailOptions params = CreateEmailOptions.builder() .from("AcmeThanks for the payment
") .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 = "AcmeThanks for the payment
", }; message.Attachments = new ListThanks for the payment
", "attachments": [ { "path": "https://resend.com/static/sample/invoice.pdf", "filename": "invoice.pdf" } ] }' ```Thanks for the payment
', attachments: [ { content: attachment, filename: 'invoice.pdf', }, ], }); ``` ```php PHP {10-11} theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->emails->send([ 'from' => 'AcmeThanks for the payment
', 'attachments' => [ [ 'filename' => 'invoice.pdf', 'content' => $invoiceBuffer ] ] ]); ``` ```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": "AcmeThanks for the payment
", "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": "AcmeThanks for the payment
", "attachments": [ { "content": file.bytes, "filename": 'invoice.pdf', } ] } Resend::Emails.send(params) ``` ```go Go {19-20} theme={"theme":{"light":"github-light","dark":"vesper"}} import ( "fmt" "os" "github.com/resend/resend-go/v3" ) 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: "AcmeThanks for the payment
", 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 = "AcmeThanks for the payment
") .with_attachment(CreateAttachment::from_content(invoice).with_filename(filename)); let _email = resend.emails.send(email).await?; Ok(()) } ``` ```java Java {8-9} 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"); Attachment att = Attachment.builder() .fileName("invoice.pdf") .content("invoiceBuffer") .build(); CreateEmailOptions params = CreateEmailOptions.builder() .from("AcmeThanks for the payment
") .attachments(att) .build(); CreateEmailOptions params = CreateEmailOptions.builder() } } ``` ```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 = "AcmeThanks for the payment
", }; message.Attachments = new ListThanks for the payment
", "attachments": [ { "content": "UmVzZW5kIGF0dGFjaG1lbnQgZXhhbXBsZS4gTmljZSBqb2Igc2VuZGluZyB0aGUgZW1haWwh%", "filename": "invoice.txt" } ] }' ``` ```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails send \ --from "AcmeThanks for the payment
" \ --attachment ./static/invoice.pdf ```Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Thanks for signing up!
', }, { from: 'AcmeYour order has been confirmed.
', }, ]); console.log(data); ``` ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->batch->send([ [ 'from' => 'AcmeThanks for signing up!
', ], [ 'from' => 'AcmeYour order has been confirmed.
', ] ]); ``` ```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": "AcmeThanks for signing up!
", }, { "from": "AcmeYour order has been confirmed.
", } ] resend.Batch.send(params) ``` ```rb Ruby theme={"theme":{"light":"github-light","dark":"vesper"}} require "resend" Resend.api_key = 're_xxxxxxxxx' params = [ { "from": "AcmeThanks for signing up!
", }, { "from": "AcmeYour order has been confirmed.
", } ] Resend::Batch.send(params) ``` ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}} package main import ( "context" "fmt" "github.com/resend/resend-go/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") var batchEmails = []*resend.SendEmailRequest{ { From: "AcmeThanks for signing up!
", }, { From: "AcmeYour order has been confirmed.
", }, } 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( "AcmeThanks for signing up!
"), CreateEmailBaseOptions::new( "AcmeYour order has been confirmed.
"), ]; let _emails = resend.batch.send(emails).await?; Ok(()) } ``` ```java Java theme={"theme":{"light":"github-light","dark":"vesper"}} import com.resend.*; import java.util.Arrays; public class Main { public static void main(String[] args) { Resend resend = new Resend("re_xxxxxxxxx"); CreateEmailOptions firstEmail = CreateEmailOptions.builder() .from("AcmeThanks for signing up!
") .build(); CreateEmailOptions secondEmail = CreateEmailOptions.builder() .from("AcmeYour order has been confirmed.
") .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 = "AcmeThanks for signing up!
", }; var mail2 = new EmailMessage() { From = "AcmeYour order has been confirmed.
", }; var resp = await resend.EmailBatchAsync([mail1, mail2]); Console.WriteLine("Nr Emails={0}", resp.Content.Data.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": "AcmeThanks for signing up!
" }, { "from": "AcmeYour order has been confirmed.
" } ]' ``` ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails batch --file ./path/to/emails.json ```it works!
', 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' => 'Acmeit works!
', '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": "it works!
", "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": "Acmeit works!
", "headers": { "X-Entity-Ref-ID": "123" }, } sent = Resend::Emails.send(params) puts sent ``` ```go Go {17} theme={"theme":{"light":"github-light","dark":"vesper"}} import ( "fmt" "github.com/resend/resend-go/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") params := &resend.SendEmailRequest{ From: "Acmeit works!
", 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 = "Acmeit works!
") .with_header("X-Entity-Ref-ID", "xxx_xxxx"); let _email = resend.emails.send(email).await?; Ok(()) } ``` ```java Java {13} 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("Acmeit works!
") .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 = "Acmeit works!
", Headers = new Dictionaryit works!
", "headers": { "X-Entity-Ref-ID": "xxx_xxxx" } }' ``` ```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails send \ --from "Acmeit works!
" \ --headers "X-Entity-Ref-ID=xxx_xxxx" ```Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
Here is our inline logo
it works!
', }, { idempotencyKey: 'welcome-user/123456789', }, ); ``` ```php PHP {9} theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->emails->send([ 'from' => 'Acmeit works!
', ], [ 'idempotency_key' => 'welcome-user/123456789', ]); ``` ```python Python {9} theme={"theme":{"light":"github-light","dark":"vesper"}} params: resend.Emails.SendParams = { "from": "Acmeit works!
" } options: resend.Emails.SendOptions = { "idempotency_key": "welcome-user/123456789", } resend.Emails.send(params, options) ``` ```rb Ruby {9} theme={"theme":{"light":"github-light","dark":"vesper"}} params = { "from": "Acmeit works!
" } 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/v3" ) 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: "it works!
", } 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 = "Acmeit works!
") .with_idempotency_key("welcome-user/123456789"); let _email = resend.emails.send(email).await?; Ok(()) } ``` ```java Java {9} theme={"theme":{"light":"github-light","dark":"vesper"}} CreateEmailOptions params = CreateEmailOptions.builder() .from("Acmeit works!
") .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.Newit works!
", } ); 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": "Acmeit works!
" }' ``` ```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails send \ --from "Acmeit works!
" \ --idempotency-key "welcome-user/123456789" ``` ```yaml SMTP {4} theme={"theme":{"light":"github-light","dark":"vesper"}} From: Acmeit works!
```it works!
', }, ], { idempotencyKey: 'team-quota/123456789', }, ); ``` ```php PHP {19} theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->batch->send( [ [ 'from' => 'Acmeit works!
', ] ], [ '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": "Acmeit works!
", } ] 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": "Acmeit works!
", } ] Resend::Batch.send( params, options: { idempotency_key: "team-quota/123456789" } ) ``` ```go Go {32} theme={"theme":{"light":"github-light","dark":"vesper"}} package main import ( "fmt" "os" "github.com/resend/resend-go/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") var batchEmails = []*resend.SendEmailRequest{ { From: "Acmeit works!
", }, } 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 {23} 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( "Acmeit works!
"), ]; let _emails = resend.batch.send_with_idempotency_key(emails, "team-quota/123456789").await?; Ok(()) } ``` ```java Java {23} 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 firstEmail = CreateEmailOptions.builder() .from("Acmeit works!
") .build(); CreateBatchEmailsResponse data = resend.batch().send( Arrays.asList(firstEmail, secondEmail), Map.of("idempotency_key", "team-quota/123456789") ); } } ``` ```csharp .NET {5} theme={"theme":{"light":"github-light","dark":"vesper"}} using Resend; IResend resend = ResendClient.Create( "re_xxxxxxxxx" ); // Or from DI var key = IdempotencyKey.Newit works!
", }; var mail2 = new EmailMessage() { From = "Acmeit works!
", }; 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": "Acmeit works!
" } ]' ```it works!
', scheduledAt: 'in 1 min', }); ``` ```php PHP {8} theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->emails->send([ 'from' => 'Acmeit works!
', '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": "Acmeit works!
", "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": "Acmeit works!
", "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/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") params := &resend.SendEmailRequest{ From: "Acmeit works!
", 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 = "Acmeit works!
") .with_scheduled_at("in 1 min"); let _email = resend.emails.send(email).await?; Ok(()) } ``` ```java Java {12} 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("Acmeit works!
") .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 = "Acmeit works!
", 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": "Acmeit works!
", "scheduled_at": "in 1 min" }' ``` ```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails send \ --from "Acmeit works!
" \ --scheduled-at "in 1 min" ```it works!
', 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' => 'Acmeit works!
', '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": "Acmeit works!
", "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": "Acmeit works!
", "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/v3" ) 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: "Acmeit works!
", 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 = "Acmeit works!
") .with_scheduled_at(&one_minute_from_now); let _email = resend.emails.send(email).await?; Ok(()) } ``` ```java Java {7-10} 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"); String oneMinuteFromNow = Instant .now() .plus(1, ChronoUnit.MINUTES) .toString(); CreateEmailOptions params = CreateEmailOptions.builder() .from("Acmeit works!
") .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 = "Acmeit works!
", 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": "Acmeit works!
", "scheduled_at": "2026-08-20T11:52:01.858Z" }' ``` ```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails send \ --from "Acmeit works!
" \ --scheduled-at "2026-08-20T11:52:01.858Z" ```it works!
', scheduledAt: 'in 5 min', }, ]); ``` ```php PHP {9,16} theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->batch->send([ [ 'from' => 'Acmeit works!
', '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": "Acmeit works!
", "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": "Acmeit works!
", "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/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") var batchEmails = []*resend.SendEmailRequest{ { From: "Acmeit works!
", 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( "Acmeit works!
") .with_scheduled_at("in 5 min"), ]; let _emails = resend.batch.send(emails).await?; Ok(()) } ``` ```java Java {13,21} theme={"theme":{"light":"github-light","dark":"vesper"}} import com.resend.*; import java.util.Arrays; public class Main { public static void main(String[] args) { Resend resend = new Resend("re_xxxxxxxxx"); CreateEmailOptions firstEmail = CreateEmailOptions.builder() .from("Acmeit works!
") .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 = "Acmeit works!
", 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": "Acmeit works!
", "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 ```it works!
', 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' => 'Acmeit works!
', '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": "Acmeit works!
", "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": "Acmeit works!
", "tags": [ {"name": "category", "value": "confirm_email"} ] } sent = Resend::Emails.send(params) puts sent ``` ```go Go {16} theme={"theme":{"light":"github-light","dark":"vesper"}} import ( "fmt" "github.com/resend/resend-go/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") params := &resend.SendEmailRequest{ From: "Acmeit works!
", 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 = "Acmeit works!
") .with_tag(Tag::new("category", "confirm_email")); let _email = resend.emails.send(email).await?; Ok(()) } ``` ```java Java {17} 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"); Tag tag = Tag.builder() .name("category") .value("confirm_email") .build(); SendEmailRequest sendEmailRequest = SendEmailRequest.builder() .from("Acmeit works!
") .tags(tag) .build(); SendEmailResponse data = resend.emails().send(sendEmailRequest); } } ``` ```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 = "Acmeit works!
", ReplyTo = "onboarding@resend.dev", Tags = new Listit works!
", "tags": [ { "name": "category", "value": "confirm_email" } ] }' ``` ```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails send \ --from "Acmeit works!
" \ --tags "category=confirm_email" ```it works!
', 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' => 'Acmeit works!
', '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": "Acmeit works!
", "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": "Acmeit works!
", "tags": [ { "name": "category", "value": "confirm_email" } ] } ] Resend::Batch.send(params) ``` ```go Go {22,29} theme={"theme":{"light":"github-light","dark":"vesper"}} package main import ( "fmt" "os" "github.com/resend/resend-go/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") var batchEmails = []*resend.SendEmailRequest{ { From: "Acmeit works!
", 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; use resend_rs::{Resend, Result}; #[tokio::main] async fn main() -> Result<()> { let resend = Resend::new("re_xxxxxxxxx"); let emails = vec![ CreateEmailBaseOptions::new( "Acmeit works!
") .with_tag(Tag::new("category", "confirm_email")), ]; let _emails = resend.batch.send(emails).await?; Ok(()) } ``` ```java Java {12-15,23-26} 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 firstEmail = CreateEmailOptions.builder() .from("Acmeit works!
") .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 = "Acmeit works!
", Tags = new Listit works!
", Tags = new Listit works!
", "tags": [ { "name": "category", "value": "confirm_email" } ] } ]' ```See attached forwarded message.
', }); ``` ```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}} 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("See attached forwarded message.
"); let data = state.resend.receiving.forward(opts).await; ```Thanks for your email!
', headers: { 'In-Reply-To': messageId, }, }); ``` ```php PHP {11} theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $messageId = $event['data']['message_id']; $data = $resend->emails->send([ 'from' => 'AcmeThanks for your email!
', 'headers' => [ 'In-Reply-To' => $messageId, ], ]); ``` ```python Python {13} theme={"theme":{"light":"github-light","dark":"vesper"}} import resend resend.api_key = "re_xxxxxxxxx" message_id = event["data"]["message_id"] params: resend.Emails.SendParams = { "from": "AcmeThanks for your email!
", "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: "AcmeThanks for your email!
", headers: { "In-Reply-To": message_id, }, } sent = Resend::Emails.send(params) ``` ```go Go {20} theme={"theme":{"light":"github-light","dark":"vesper"}} import ( "fmt" "context" "github.com/resend/resend-go/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") messageId := event.Data.MessageId params := &resend.SendEmailRequest{ From: "AcmeThanks for your email!
", 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::types::CreateEmailBaseOptions; use resend_rs::{Resend, Result}; #[tokio::main] async fn main() -> Result<()> { let resend = Resend::new("re_xxxxxxxxx"); let message_id = &event.data.received.unwrap().message_id; let subject = format!("Re: {}", event.data.subject); let email = CreateEmailBaseOptions::new( "AcmeThanks for your email!
") .with_header("In-Reply-To", message_id); let _email = resend.emails.send(email).await?; Ok(()) } ``` ```java Java {15} 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"); String messageId = event.getData().getMessageId(); CreateEmailOptions params = CreateEmailOptions.builder() .from("AcmeThanks for your email!
") .headers(Map.of( "In-Reply-To", messageId )) .build(); CreateEmailResponse data = resend.emails().send(params); } } ``` ```csharp .NET {16} theme={"theme":{"light":"github-light","dark":"vesper"}} using Resend; using System.Collections.Generic; IResend resend = ResendClient.Create("re_xxxxxxxxx"); var messageId = eventData.MessageId; var message = new EmailMessage() { From = "AcmeThanks for your email!
", Headers = new DictionaryThanks for your email!
", "headers": { "In-Reply-To": "<111-222-333@email.example.com>" } }' ``` ```bash CLI {6} theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails send \ --from "AcmeThanks for your email!
" \ --headers "In-Reply-To=<111-222-333@email.example.com>" ``` ```rust Rust theme={"theme":{"light":"github-light","dark":"vesper"}} async fn example( State(state): StateThanks for your email!
") .with_header("In-Reply-To", &event.data.received.unwrap().message_id); let data = state.resend.emails.send(email).await.unwrap(); Json(data).into_response() } else { Json(Empty {}).into_response() } } ```Thanks for your email!
', headers: { 'In-Reply-To': event.data.message_id, 'References': [...previousReferences, event.data.message_id].join(' '), }, }); ``` ```php PHP {9-10} theme={"theme":{"light":"github-light","dark":"vesper"}} $previousReferences = ['Thanks for your email!
', 'headers' => [ 'In-Reply-To' => $event['data']['message_id'], 'References' => implode(' ', [...$previousReferences, $event['data']['message_id']]), ], ]); ``` ```python Python {9-10} theme={"theme":{"light":"github-light","dark":"vesper"}} previous_references = ["Thanks for your email!
", "headers": { "In-Reply-To": event["data"]["message_id"], "References": " ".join([*previous_references, event["data"]["message_id"]]), }, } email = resend.Emails.send(params) ``` ```rb Ruby {9-10} theme={"theme":{"light":"github-light","dark":"vesper"}} previous_references = ["Thanks for your email!
", headers: { "In-Reply-To": event["data"]["message_id"], "References": [*previous_references, event["data"]["message_id"]].join(" "), }, } sent = Resend::Emails.send(params) ``` ```go Go {11-12} theme={"theme":{"light":"github-light","dark":"vesper"}} previousReferences := []string{"Thanks for your email!
", Headers: map[string]string{ "In-Reply-To": event.Data.MessageId, "References": strings.Join(allReferences, " "), }, } sent, err := client.Emails.SendWithContext(ctx, params) ``` ```rust Rust {13-14} theme={"theme":{"light":"github-light","dark":"vesper"}} let previous_references = vec!["Thanks for your email!
") .with_header("In-Reply-To", &event.data.message_id) .with_header("References", &all_references); let _email = resend.emails.send(email).await?; ``` ```java Java {12-13} theme={"theme":{"light":"github-light","dark":"vesper"}} ListThanks for your email!
") .headers(Map.of( "In-Reply-To", event.getData().getMessageId(), "References", String.join(" ", allReferences) )) .build(); CreateEmailResponse data = resend.emails().send(params); ``` ```csharp .NET {12-13} theme={"theme":{"light":"github-light","dark":"vesper"}} var previousReferences = new ListThanks for your email!
", Headers = new DictionaryThanks for your email!
", "headers": { "In-Reply-To": "<111-222-333@email.example.com>", "References": "Thanks for your email!
" \ --headers "In-Reply-To=<111-222-333@email.example.com>" \ "References=Thanks for your email!
") .with_header("In-Reply-To", &received.message_id) .with_header("References", &previous_references.join(" ")); let data = state.resend.emails.send(email).await.unwrap(); ```Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
', 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 StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
', '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 StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", "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 StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 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/v3" client := resend.NewClient("re_xxxxxxxxx") template, err := client.Templates.Create(&resend.CreateTemplateRequest{ Name: "order-confirmation", From: "Resend StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 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 StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
"; let variables = [ Variable::new("PRODUCT", VariableType::String).with_fallback("item"), Variable::new("PRICE", VariableType::Number).with_fallback(20) ]; let opts = CreateTemplateOptions::new(name, from, subject) .with_html(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.*; public class Main { public static void main(String[] args) { Resend resend = new Resend("re_xxxxxxxxx"); CreateTemplateOptions params = CreateTemplateOptions.builder() .name("order-confirmation") .from("Resend StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
") .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 ListName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 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 StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", "variables": [ { "key": "PRODUCT", "type": "string", "fallback_value": "item" }, { "key": "PRICE", "type": "number", "fallback_value": 20 } ] }' ```
You can create a Template from an existing Broadcast. Locate your desired
Broadcast in the [Broadcast dashboard](https://resend.com/broadcasts), click
the more options button
You can also define custom variables via the API. The payload can optionally include variables to be used in the Template.
Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
', 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' => 'Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
', '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": "Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
", "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: "Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
", variables: [ { key: "PRODUCT", type: "string", fallback_value: "item" }, { key: "PRICE", type: "number", fallback_value: 25 } ] ) ``` ```go Go theme={"theme":{"light":"github-light","dark":"vesper"}} import ( "context" "github.com/resend/resend-go/v3" ) func main() { client := resend.NewClient("re_xxxxxxxxx") template, err := client.Templates.CreateWithContext(context.TODO(), &resend.CreateTemplateRequest{ Name: "order-confirmation", Html: "Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 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 = "Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
"; 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.*; public class Main { public static void main(String[] args) { Resend resend = new Resend("re_xxxxxxxxx"); CreateTemplateOptions params = CreateTemplateOptions.builder() .name("order-confirmation") .html("Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
") .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 ListName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", "variables": [ { "key": "PRODUCT", "type": "string", "fallback_value": "item" }, { "key": "PRICE", "type": "number", "fallback_value": 25 } ] }' ```Name: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 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 await resend.templates.create({ ... }).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 StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 'variables' => [ [ 'key' => 'PRODUCT', 'type' => 'string', 'fallbackValue' => 'item' ], [ 'key' => 'PRICE', 'type' => 'number', 'fallbackValue' => 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 StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", "variables": [ { "key": "PRODUCT", "type": "string", "fallbackValue": "item" }, { "key": "PRICE", "type": "number", "fallbackValue": 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 StoreName: #{{{PRODUCT}}}
Total: #{{{PRICE}}}
", "variables": [{ "key": 'PRODUCT', "type": 'string', "fallbackValue": 'item' }, { "key": 'PRICE', "type": 'number', "fallbackValue": 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/v2" client := resend.NewClient("re_xxxxxxxxx") // Create template params := &resend.CreateTemplateRequest{ Name: "order-confirmation", From: "Resend StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 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, Resend, Result}; #[tokio::main] async fn main() -> Result<()> { let resend = Resend::new("re_xxxxxxxxx"); // Create template let name = "order-confirmation"; let from = "Resend StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
"; let variables = vec![ TemplateVariable { key: "PRODUCT", type_: "string", fallback_value: Some("item"), }, TemplateVariable { key: "PRICE", type_: "number", fallback_value: Some(20), }, ]; let opts = CreateTemplateOptions::new(name, from, subject) .with_html(html) .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"}} Resend resend = new Resend("re_xxxxxxxxx"); // Create template ListName: {{{PRODUCT}}}
Total: {{{PRICE}}}
") .variables(variables) .build(); CreateTemplateResponseSuccess data = resend.templates().create(params); // Publish template resend.templates().publish(data.content); ``` ```csharp .NET theme={"theme":{"light":"github-light","dark":"vesper"}} using Resend; IResend resend = ResendClient.Create("re_xxxxxxxxx"); // Create template var variables = new ListName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", 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 StoreName: {{{PRODUCT}}}
Total: {{{PRICE}}}
", "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' ```Hello World
', }), }); ```Hello World
', }); ``` **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 requestType "/" for a command, or select text to format it.
`; export function Editor() { returnThanks for signing up!
', }); ``` ```php PHP theme={"theme":{"light":"github-light","dark":"vesper"}} $resend = Resend::client('re_xxxxxxxxx'); $resend->emails->send([ 'from' => 'AcmeThanks for signing up!
' ]); ``` ```python Python theme={"theme":{"light":"github-light","dark":"vesper"}} import resend resend.api_key = "re_xxxxxxxxx" params: resend.Emails.SendParams = { "from": "AcmeThanks for signing up!
" } 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": "AcmeThanks for signing up!
" } 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/v3" ) func main() { ctx := context.TODO() client := resend.NewClient("re_xxxxxxxxx") params := &resend.SendEmailRequest{ From: "AcmeThanks for signing up!
", } 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 = "AcmeThanks for signing up!
"; 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("AcmeThanks for signing up!
") .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 = "AcmeThanks for signing up!
", } ); 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": "AcmeThanks for signing up!
" }' ``` ```bash CLI theme={"theme":{"light":"github-light","dark":"vesper"}} resend emails send \ --from "AcmeThanks for signing up!
" ```Your order #1234 is on its way.
', }); ``` ### 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 infrastructureThanks for signing up.
', 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 accountsSee attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)Hi ${event.user.name}, a new login was detected from ${event.request.ip}.
`, }); } }; ``` 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: 'SecuritySee attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)Thank you for joining our service.
Your account email: {{ user_email }}
``` 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="AcmeSee attached invoice.
", 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: "AcmeThis is your reminder.
", 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: "AcmeWelcome aboard!
", 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/v3`? 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)Thanks for signing up.
', }); ``` ### 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/contact). ### 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: `See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)Thanks for signing up.
', }); ```See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)You have successfully signed up to example.com,
To log in to the site, just follow this link: <%= @url %>.
Thanks for joining and have a great day!
``` 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 # => #You have successfully signed up to example.com,
To log in to the site, just follow this link: <%= @url %>.
Thanks for joining and have a great day!
``` 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 # => #See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)it works!
``` 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:See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)Hello world
', }); if (error) { return Response.json({ error }, { status: 500 }); } return Response.json({ data }); } catch (error) { return Response.json({ error }, { status: 500 }); } } ```See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)See attached invoice.
', 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: 'AcmeThis is your reminder.
', 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: 'AcmeWelcome aboard!
', 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)