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

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

## Body Parameters

<ParamField type="string">
  The API key name.
</ParamField>

<ParamField type="full_access | sending_access">
  The API key can have full access to Resend's API or be only restricted to send
  emails. \* `full_access`: Can create, delete, get, and update any resource. \*
  `sending_access`: Can only send emails.
</ParamField>

<ResendParamField type="string">
  Restrict an API key to send emails only from a specific domain. This is only
  used when the `permission` is set to `sending_access`.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

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

  resend.ApiKeys.create(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

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

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

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

  ```rust Rust theme={null}
  use resend_rs::{types::CreateApiKeyOptions, Resend, Result};

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

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

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

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

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

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/api-keys' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "Production"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "dacf4072-4119-4d88-932f-6202748ac7c8",
    "token": "re_c1tpEyD8_NKFusih9vKVQknRAQfmFcWCv"
  }
  ```
</ResponseExample>


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

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

## Path Parameters

<ResendParamField type="string">
  The API key ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

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

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

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

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

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

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

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

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

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

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X DELETE 'https://api.resend.com/api-keys/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```text Response theme={null}
  HTTP 200 OK
  ```
</ResponseExample>


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

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

<QueryParams type="API keys" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

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

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::ApiKeys.list
  ```

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")
  keys, err := client.ApiKeys.List()
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result, list_opts::ListOptions};

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

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

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

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

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/api-keys' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "91f3200a-df72-4654-b0cd-f202395f5354",
        "name": "Production",
        "created_at": "2023-04-08T00:11:13.110779+00:00"
      }
    ]
  }
  ```
</ResponseExample>


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

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

## Body Parameters

<ResendParamField type="string">
  The ID of the segment you want to send to.

  <Info>
    Audiences are now called Segments. Follow the [Migration
    Guide](/dashboard/segments/migrating-from-audiences-to-segments).
  </Info>
</ResendParamField>

<ParamField type="string">
  Sender email address.

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

<ParamField type="string">
  Email subject.
</ParamField>

<ResendParamField type="string | string[]">
  Reply-to email address. For multiple addresses, send as an array of strings.
</ResendParamField>

<ParamField type="string">
  The HTML version of the message. You can include Contact Properties in the
  body of the Broadcast. Learn more about [Contact
  Properties](/dashboard/audiences/contacts).
</ParamField>

<ParamField type="string">
  The plain text version of the message. You can include Contact Properties in the body of the Broadcast. Learn more about [Contact Properties](/dashboard/audiences/contacts).

  <Info>
    If not provided, the HTML will be used to generate a plain text version. You
    can opt out of this behavior by setting value to an empty string.
  </Info>
</ParamField>

<ParamField type="React.ReactNode">
  The React component used to write the message. *Only available in the Node.js
  SDK.*
</ParamField>

<ParamField type="string">
  The friendly name of the broadcast. Only used for internal reference.
</ParamField>

<ResendParamField type="string">
  The topic ID that the broadcast will be scoped to.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Broadcasts.CreateParams = {
    "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    "from": "Acme <onboarding@resend.dev>",
    "subject": "Hello, world!",
    "html": "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  }

  resend.Broadcasts.create(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

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

  ```go Go theme={null}
  import "fmt"
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateBroadcastRequest{
    SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    From:       "Acme <onboarding@resend.dev>",
    Html:       "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
    Subject:    "Hello, world!",
  }

  broadcast, _ := client.Broadcasts.Create(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::CreateBroadcastOptions, Resend, Result};

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

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

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

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

    Ok(())
  }
  ```

  ```java Java theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

  CreateBroadcastOptions params = CreateBroadcastOptions.builder()
      .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
      .from("Acme <onboarding@resend.dev>")
      .subject("hello world")
      .html("Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
      .build();

  CreateBroadcastResponseSuccess data = resend.broadcasts().create(params);
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.BroadcastAddAsync(
      new BroadcastData()
      {
          DisplayName = "Example Broadcast",
          SegmentId = new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ),
          From = "Acme <onboarding@resend.dev>",
          Subject = "Hello, world!",
          HtmlBody = "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
      }
  );
  Console.WriteLine( "Broadcast Id={0}", resp.Content );
  ```

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

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
  }
  ```
</ResponseExample>


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

DELETE /broadcasts/:broadcast_id
Remove an existing broadcast.

You can only delete broadcasts that are in the `draft` status. In addition, if you delete a broadcast that has already been scheduled to be sent, we will automatically cancel the scheduled delivery and it won't be sent.

## Path Parameters

<ResendParamField type="string">
  The broadcast ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

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

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

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

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  removed, _ := client.Broadcasts.Remove("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

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

    Ok(())
  }
  ```

  ```java Java theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

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

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X DELETE 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "broadcast",
    "id": "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
    "deleted": true
  }
  ```
</ResponseExample>


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

GET /broadcasts/:broadcast_id
Retrieve a single broadcast.

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

## Path Parameters

<ResendParamField type="string">
  The broadcast ID.
</ResendParamField>

<Info>
  See all available `status` types in [the Broadcasts
  overview](/dashboard/broadcasts/introduction#understand-broadcast-statuses).
</Info>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

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

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

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

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  broadcast, _ := client.Broadcasts.Get("559ac32e-9ef5-46fb-82a1-b76b840c0f7b")
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

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

    Ok(())
  }
  ```

  ```java Java theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

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

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/broadcasts/559ac32e-9ef5-46fb-82a1-b76b840c0f7b' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

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


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

GET /broadcasts
Retrieve a list of broadcast.

<Info>
  See all available `status` types in [the Broadcasts
  overview](/dashboard/broadcasts/introduction#understand-broadcast-statuses).
</Info>

<QueryParams type="broadcasts" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Broadcasts.list()
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Broadcasts.list()
  ```

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  broadcasts, _ := client.Broadcasts.List()
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result, list_opts::ListOptions};

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

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

    Ok(())
  }
  ```

  ```java Java theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

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

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/broadcasts' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
        "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf", // now called segment_id
        "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
        "status": "draft",
        "created_at": "2024-11-01T15:13:31.723Z",
        "scheduled_at": null,
        "sent_at": null,
        "topic_id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
      },
      {
        "id": "559ac32e-9ef5-46fb-82a1-b76b840c0f7b",
        "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf", // now called segment_id
        "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
        "status": "sent",
        "created_at": "2024-12-01T19:32:22.980Z",
        "scheduled_at": "2024-12-02T19:32:22.980Z",
        "sent_at": "2024-12-02T19:32:22.980Z",
        "topic_id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
      }
    ]
  }
  ```
</ResponseExample>


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

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

<Note>You can send broadcasts only if they were created via the API.</Note>

## Path Parameters

<ResendParamField type="string">
  The broadcast ID.
</ResendParamField>

## Body Parameters

<ResendParamField type="string">
  Schedule email to be sent later. The date should be in natural language (e.g.:
  `in 1 min`) or ISO 8601 format (e.g: `2024-08-05T11:52:01.858Z`).
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

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

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

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

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

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

  sent, _ := client.Broadcasts.Send(sendParams)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::SendBroadcastOptions, Resend, Result};

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

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

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

    Ok(())
  }
  ```

  ```java Java theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

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

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

  ```csharp .NET theme={null}
  using Resend;

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

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

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

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

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
  }
  ```
</ResponseExample>


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

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

## Path Parameters

<ResendParamField type="string">
  The ID of the broadcast you want to update.
</ResendParamField>

## Body Parameters

<ResendParamField type="string">
  The ID of the segment you want to send to.

  <Info>
    Audiences are now called Segments. Follow the [Migration
    Guide](/dashboard/segments/migrating-from-audiences-to-segments).
  </Info>
</ResendParamField>

<ParamField type="string">
  Sender email address.

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

<ParamField type="string">
  Email subject.
</ParamField>

<ResendParamField type="string | string[]">
  Reply-to email address. For multiple addresses, send as an array of strings.
</ResendParamField>

<ParamField type="string">
  The HTML version of the message.
</ParamField>

<ParamField type="string">
  The plain text version of the message.

  <Info>
    If not provided, the HTML will be used to generate a plain text version. You
    can opt out of this behavior by setting value to an empty string.
  </Info>
</ParamField>

<ParamField type="React.ReactNode">
  The React component used to write the message. *Only available in the Node.js
  SDK.*
</ParamField>

<ParamField type="string">
  The friendly name of the broadcast. Only used for internal reference.
</ParamField>

<ResendParamField type="string">
  The topic ID that the broadcast will be scoped to.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.broadcasts.update(
    '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794',
    {
      html: 'Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
    },
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->broadcasts->update('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794', [
    'html' => 'Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}',
  ]);
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Broadcasts.UpdateParams = {
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    "html": "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}"
  }

  resend.Broadcasts.update(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    "html": "Hi #{FIRST_NAME}, you can unsubscribe here: #{RESEND_UNSUBSCRIBE_URL}",
  }
  Resend::Broadcasts.update(params)
  ```

  ```go Go theme={null}
  import "fmt"
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.UpdateBroadcastRequest{
    Id: "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    Html: fmt.Sprintf("Hi %s, you can unsubscribe here: %s", FIRST_NAME, RESEND_UNSUBSCRIBE_URL),
  }

  broadcast, _ := client.Broadcasts.Update(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::UpdateBroadcastOptions, Resend, Result};

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

    let id = "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794";
    let html = "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}";

    let opts = UpdateBroadcastOptions::new().with_html(html);

    let _broadcast = resend.broadcasts.update(id, opts).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

  UpdateBroadcastOptions params = UpdateBroadcastOptions.builder()
      .id("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
      .html("Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
      .build();

  UpdateBroadcastResponseSuccess data = resend.broadcasts().update(params);
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.BroadcastUpdateAsync(
      new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ),
      new BroadcastUpdateData()
      {
          HtmlBody = "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
      }
  );
  ```

  ```bash cURL theme={null}
  curl -X PATCH 'https://api.resend.com/broadcasts/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "html": "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
  }
  ```
</ResponseExample>


# Create Contact Property
Source: https://resend.com/docs/api-reference/contact-properties/create-contact-property

POST /contact-properties
Create a custom property for your contacts.

## Body Parameters

<ResendParamField type="string">
  The property key. Max length is `50` characters. Only alphanumeric characters
  and underscores are allowed.
</ResendParamField>

<ResendParamField type="string">
  The property type. Possible values: `string` or `number`.
</ResendParamField>

<ResendParamField type="string | number">
  The default value to use when the property is not set for a contact. Must
  match the type specified in the `type` field.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.contactProperties.create({
    key: 'company_name',
    type: 'string',
    fallbackValue: 'Acme Corp',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->contactProperties->create([
    'key' => 'company_name',
    'type' => 'string',
    'fallback_value' => 'Acme Corp',
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  params = {
      "key": "company_name",
      "type": "string",
      "fallback_value": "Acme Corp",
  }

  contact_property = resend.ContactProperties.create(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  property = Resend::ContactProperties.create({
    key: "company_name",
    type: "string",
    fallback_value: "Acme Corp"
  })
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	params := &resend.CreateContactPropertyRequest{
  		Key:           "company_name",
  		Type:          "string",
  		FallbackValue: "Acme Corp",
  	}

  	property, err := client.ContactProperties.CreateWithContext(ctx, params)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(property)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    types::{CreateContactPropertyOptions, PropertyType},
    Resend, Result,
  };

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

    let contact_property = CreateContactPropertyOptions::new("company_name", PropertyType::String)
      .with_fallback("Acme Corp");

    let _contact_property = resend.contacts.create_property(contact_property).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      CreateContactPropertyOptions options = CreateContactPropertyOptions.builder()
        .key("company_name")
        .type("string")
        .fallbackValue("Acme Corp")
        .build();

      resend.contactProperties().create(options);
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ContactPropCreateAsync( new ContactPropertyData() {
    Key = "company_name",
    PropertyType = ContactPropertyType.String,
    DefaultValue = "Acme Corp",
  } );
  Console.WriteLine( "Prop Id={0}", resp.Content );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/contact-properties' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "key": "company_name",
    "type": "string",
    "fallback_value": "Acme Corp"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "contact_property",
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
  }
  ```
</ResponseExample>


# Delete Contact Property
Source: https://resend.com/docs/api-reference/contact-properties/delete-contact-property

DELETE /contact-properties/:contact_property_id
Remove an existing contact property.

## Path Parameters

<ResendParamField type="string">
  The Contact Property ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  contact_property = resend.ContactProperties.remove('b6d24b8e-af0b-4c3c-be0c-359bbd97381e')
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::ContactProperties.remove("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	property, err := client.ContactProperties.RemoveWithContext(ctx, "b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(property)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _deleted = resend
      .contacts
      .delete_property("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

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

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X DELETE 'https://api.resend.com/contact-properties/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "contact_property",
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    "deleted": true
  }
  ```
</ResponseExample>


# Retrieve Contact Property
Source: https://resend.com/docs/api-reference/contact-properties/get-contact-property

GET /contact-properties/:contact_property_id
Retrieve a contact property by its ID.

## Path Parameters

<ResendParamField type="string">
  The Contact Property ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->contactProperties->get('b6d24b8e-af0b-4c3c-be0c-359bbd97381');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  contact_property = resend.ContactProperties.get('b6d24b8e-af0b-4c3c-be0c-359bbd97381e')
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  property = Resend::ContactProperties.get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	property, err := client.ContactProperties.GetWithContext(ctx, "b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(property)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _property = resend
      .contacts
      .get_property("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

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

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ContactPropRetrieveAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
  Console.WriteLine( "Prop Id={0}", resp.Content.Id );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/contact-properties/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "contact_property",
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    "key": "company_name",
    "type": "string",
    "fallback_value": "Acme Corp",
    "created_at": "2023-04-08T00:11:13.110779+00:00"
  }
  ```
</ResponseExample>


# List Contact Properties
Source: https://resend.com/docs/api-reference/contact-properties/list-contact-properties

GET /contact-properties
Retrieve a list of contact properties.

<QueryParams type="contact-properties" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  contact_properties = resend.ContactProperties.list()
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  properties = Resend::ContactProperties.list
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	properties, err := client.ContactProperties.ListWithContext(ctx)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(properties)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let _contact_properties = resend
      .contacts
      .list_properties(ListOptions::default())
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

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

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/contact-properties' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
        "key": "company_name",
        "type": "string",
        "fallback_value": "Acme Corp",
        "created_at": "2023-04-08T00:11:13.110779+00:00"
      }
    ]
  }
  ```
</ResponseExample>


# Update Contact Property
Source: https://resend.com/docs/api-reference/contact-properties/update-contact-property

PATCH /contact-properties/:contact_property_id
Update an existing contact property.

## Path Parameters

<ResendParamField type="string">
  The Contact Property ID.
</ResendParamField>

<Note>
  The `key` and `type` fields cannot be changed after creation. This preserves
  data integrity for existing contact values.
</Note>

## Body Parameters

<ResendParamField type="string | number">
  The default value to use when the property is not set for a contact. Must
  match the type of the property.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.contactProperties.update({
    id: 'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
    fallbackValue: 'Example Company',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->contactProperties->update('b6d24b8e-af0b-4c3c-be0c-359bbd97381', [
    'fallback_value' => 'Example Company',
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  params = {
      "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
      "fallback_value": "Example Company",
  }

  contact_property = resend.ContactProperties.update(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  property = Resend::ContactProperties.update({
    id: "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    fallback_value: "Example Company"
  })
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	params := &resend.UpdateContactPropertyRequest{
  		Id:            "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  		FallbackValue: "Example Company",
  	}

  	property, err := client.ContactProperties.UpdateWithContext(ctx, params)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(property)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::ContactPropertyChanges, Resend, Result};

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

    let update = ContactPropertyChanges::default().with_fallback("Example Company");
    let _contact_property = resend
      .contacts
      .update_property("b6d24b8e-af0b-4c3c-be0c-359bbd97381e", update)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      UpdateContactPropertyOptions options = UpdateContactPropertyOptions.builder()
        .id("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
        .fallbackValue("Example Company")
        .build();

      resend.contactProperties().update(options);
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ContactPropUpdateAsync(
    new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ),
    new ContactPropertyUpdateData() {
      DefaultValue = "Example Company",
    }
  );
  ```

  ```bash cURL theme={null}
  curl -X PATCH 'https://api.resend.com/contact-properties/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "fallback_value": "Example Company"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "contact_property",
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
  }
  ```
</ResponseExample>


# Add Contact to Segment
Source: https://resend.com/docs/api-reference/contacts/add-contact-to-segment

POST /contacts/:contact_id/segments/:segment_id
Add an existing contact to a segment.

## Path Parameters

Either `id` or `email` must be provided.

<ParamField type="string">
  The Contact ID.
</ParamField>

<ParamField type="string">
  The Contact Email.
</ParamField>

<ResendParamField type="string">
  The Segment ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Add by contact id
  const { data, error } = await resend.contacts.segments.add({
    contactId: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  });

  // Add by contact email
  const { data, error } = await resend.contacts.segments.add({
    email: 'steve.wozniak@gmail.com',
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Add by contact id
  $resend->contacts->segments->add(
    contact: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
  );

  // Add by contact email
  $resend->contacts->segments->add(
    contact: 'steve.wozniak@gmail.com',
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  # Add by contact id
  params = {
      "segment_id": '78261eea-8f8b-4381-83c6-79fa7120f1cf',
      "contact_id": 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  }

  response = resend.Contacts.Segments.add(params)
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  # Add by contact id
  result = Resend::Contacts::Segments.add(
    contact_id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    segment_id: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
  )

  # Add by contact email
  result = Resend::Contacts::Segments.add(
    email: 'steve.wozniak@gmail.com',
    segment_id: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
  )
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	// Add by contact id
  	addParams := &resend.AddContactSegmentRequest{
  		ContactId: "e169aa45-1ecf-4183-9955-b1499d5701d3",
  		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  	}

  	response, err := client.Contacts.Segments.AddWithContext(ctx, addParams)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(response)

  	// Add by contact email
  	addByEmailParams := &resend.AddContactSegmentRequest{
  		Email:     "steve.wozniak@gmail.com",
  		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  	}

  	response, err = client.Contacts.Segments.AddWithContext(ctx, addByEmailParams)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(response)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    // Update by contact id
    let _contact = resend
      .contacts
      .add_contact_segment(
        "e169aa45-1ecf-4183-9955-b1499d5701d3",
        "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      )
      .await?;

    // // Update by contact email
    let _contact = resend
      .contacts
      .add_contact_segment(
        "steve.wozniak@gmail.com",
        "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      )
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      // Add by contact id
      AddContactToSegmentOptions optionsById = AddContactToSegmentOptions.builder()
        .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
        .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
        .build();

      resend.contacts().segments().add(optionsById);

      // Add by contact email
      AddContactToSegmentOptions optionsByEmail = AddContactToSegmentOptions.builder()
        .email("steve.wozniak@gmail.com")
        .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
        .build();

      resend.contacts().segments().add(optionsByEmail);
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.ContactAddToSegmentAsync(
      contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
      segmentId: new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" )
  );
  ```

  ```bash cURL theme={null}
  // Update by contact id
  curl -X POST 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
       -H 'Authorization: Bearer re_xxxxxxxxx'

  // Update by contact email
  curl -X POST 'https://api.resend.com/contacts/steve.wozniak@gmail.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf"
  }
  ```
</ResponseExample>


# Create Contact
Source: https://resend.com/docs/api-reference/contacts/create-contact

POST /contacts
Create a contact.

## Body Parameters

<ParamField type="string">
  The email address of the contact.
</ParamField>

<ResendParamField type="string">
  The first name of the contact.
</ResendParamField>

<ResendParamField type="string">
  The last name of the contact.
</ResendParamField>

<ParamField type="boolean">
  The Contact's global subscription status. If set to `true`, the contact will
  be unsubscribed from all Broadcasts.
</ParamField>

<ParamField type="object">
  A map of custom property keys and values to create.

  <Expandable title="custom properties">
    <ParamField type="string">
      The property key.
    </ParamField>

    <ParamField type="string">
      The property value.
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type="array">
  Array of segment IDs to add the contact to.

  <Expandable title="segments">
    <ParamField type="string">
      The segment ID.
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type="array">
  Array of topic subscriptions for the contact.

  <Expandable title="topics">
    <ParamField type="string">
      The topic ID.
    </ParamField>

    <ParamField type="'opt_in' | 'opt_out'">
      The subscription status for this topic.
    </ParamField>
  </Expandable>
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.contacts.create({
    email: 'steve.wozniak@gmail.com',
    firstName: 'Steve',
    lastName: 'Wozniak',
    unsubscribed: false,
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->contacts->create(
    parameters: [
      'email' => 'steve.wozniak@gmail.com',
      'first_name' => 'Steve',
      'last_name' => 'Wozniak',
      'unsubscribed' => false
    ]
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Contacts.CreateParams = {
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
    "unsubscribed": False,
  }

  resend.Contacts.create(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
    "unsubscribed": false,
  }

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

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateContactRequest{
    Email:        "steve.wozniak@gmail.com",
    FirstName:    "Steve",
    LastName:     "Wozniak",
    Unsubscribed: false,
  }

  contact, err := client.Contacts.Create(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::CreateContactOptions, Resend, Result};

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

    let contact = CreateContactOptions::new("steve.wozniak@gmail.com")
      .with_first_name("Steve")
      .with_last_name("Wozniak")
      .with_unsubscribed(false);

    let _contact = resend.contacts.create(contact).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          CreateContactOptions params = CreateContactOptions.builder()
                  .email("steve.wozniak@gmail.com")
                  .firstName("Steve")
                  .lastName("Wozniak")
                  .unsubscribed(false)
                  .build();

          CreateContactResponseSuccess data = resend.contacts().create(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ContactAddAsync(
      new ContactData()
      {
          Email = "steve.wozniak@gmail.com",
          FirstName = "Steve",
          LastName = "Wozniak",
          IsUnsubscribed = false,
      }
  );
  Console.WriteLine( "Contact Id={0}", resp.Content );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/contacts' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
    "unsubscribed": false
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "contact",
    "id": "479e3145-dd38-476b-932c-529ceb705947"
  }
  ```
</ResponseExample>


# Delete Contact
Source: https://resend.com/docs/api-reference/contacts/delete-contact

DELETE /contacts/:id
Remove an existing contact.

## Path Parameters

Either `id` or `email` must be provided.

<ParamField type="string">
  The Contact ID.
</ParamField>

<ParamField type="string">
  The Contact email.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Delete by contact id
  const { data, error } = await resend.contacts.remove({
    id: '520784e2-887d-4c25-b53c-4ad46ad38100',
  });

  // Delete by contact email
  const { data, error } = await resend.contacts.remove({
    email: 'acme@example.com',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Delete by contact id
  $resend->contacts->remove(
    id: '520784e2-887d-4c25-b53c-4ad46ad38100'
  );

  // Delete by contact email
  $resend->contacts->remove(
    email: 'acme@example.com'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  # Delete by contact id
  resend.Contacts.remove(
    id="520784e2-887d-4c25-b53c-4ad46ad38100"
  )

  # Delete by contact email
  resend.Contacts.remove(
    email="acme@example.com"
  )
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  # Delete by contact id
  Resend::Contacts.remove(
    id: "520784e2-887d-4c25-b53c-4ad46ad38100"
  )

  # Delete by contact email
  Resend::Contacts.remove(
    email: "acme@example.com"
  )
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  // Delete by contact id
  removed, err := client.Contacts.Remove(
    "520784e2-887d-4c25-b53c-4ad46ad38100"
  )

  // Delete by contact email
  removed, err := client.Contacts.Remove(
    "acme@example.com"
  )
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    // Delete by contact id
    let _deleted = resend
      .contacts
      .delete("520784e2-887d-4c25-b53c-4ad46ad38100")
      .await?;

    // Delete by contact email
    let _deleted = resend
      .contacts
      .delete("acme@example.com")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          // Delete by contact id
          resend.contacts().remove(ContactRequestOptions.builder()
                          .id("520784e2-887d-4c25-b53c-4ad46ad38100")
                          .build());

          // Delete by contact email
          resend.contacts().remove(ContactRequestOptions.builder()
                          .email("acme@example.com")
                          .build());
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  // By Id
  await resend.ContactDeleteAsync(
      contactId: new Guid( "520784e2-887d-4c25-b53c-4ad46ad38100" )
  );

  // By Email
  await resend.ContactDeleteByEmailAsync(
      "acme@example.com"
  );
  ```

  ```bash cURL theme={null}
  # Delete by contact id
  curl -X DELETE 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
       -H 'Authorization: Bearer re_xxxxxxxxx'

  # Deleted by contact email
  curl -X DELETE 'https://api.resend.com/contacts/acme@example.com' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "contact",
    "contact": "520784e2-887d-4c25-b53c-4ad46ad38100",
    "deleted": true
  }
  ```
</ResponseExample>


# Delete Contact Segment
Source: https://resend.com/docs/api-reference/contacts/delete-contact-segment

DELETE /contacts/:contact_id/segments/:segment_id
Remove an existing contact from a segment.

## Path Parameters

Either `id` or `email` must be provided.

<ParamField type="string">
  The Contact ID.
</ParamField>

<ParamField type="string">
  The Contact Email.
</ParamField>

<ResendParamField type="string">
  The Segment ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Remove by contact id
  const { data, error } = await resend.contacts.segments.remove({
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  });

  // Remove by contact email
  const { data, error } = await resend.contacts.segments.remove({
    email: 'steve.wozniak@gmail.com',
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Remove by contact id
  $resend->contacts->segments->remove(
    contact: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
  );

  // Remove by contact email
  $resend->contacts->segments->remove(
    contact: 'steve.wozniak@gmail.com',
    segmentId: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  # Remove by contact id
  params = {
      "segment_id": '78261eea-8f8b-4381-83c6-79fa7120f1cf',
      "contact_id": 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  }

  response = resend.Contacts.Segments.remove(params)
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  # Remove by contact id
  removed = Resend::Contacts::Segments.remove(
    contact_id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    segment_id: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
  )

  # Remove by contact email
  removed = Resend::Contacts::Segments.remove(
    email: 'steve.wozniak@gmail.com',
    segment_id: '78261eea-8f8b-4381-83c6-79fa7120f1cf'
  )
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	// Remove by contact id
  	removeParams := &resend.RemoveContactSegmentRequest{
  		ContactId: "e169aa45-1ecf-4183-9955-b1499d5701d3",
  		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  	}

  	response, err := client.Contacts.Segments.RemoveWithContext(ctx, removeParams)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(response)

  	// Remove by contact email
  	removeByEmailParams := &resend.RemoveContactSegmentRequest{
  		Email:     "steve.wozniak@gmail.com",
  		SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
  	}

  	response, err = client.Contacts.Segments.RemoveWithContext(ctx, removeByEmailParams)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(response)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    // Update by contact id
    let _contact = resend
      .contacts
      .delete_contact_segment(
        "e169aa45-1ecf-4183-9955-b1499d5701d3",
        "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      )
      .await?;

    // // Update by contact email
    let _contact = resend
      .contacts
      .delete_contact_segment(
        "steve.wozniak@gmail.com",
        "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      )
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      // Remove by contact id
      RemoveContactFromSegmentOptions optionsById = RemoveContactFromSegmentOptions.builder()
        .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
        .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
        .build();

      resend.contacts().segments().remove(optionsById);

      // Remove by contact email
      RemoveContactFromSegmentOptions optionsByEmail = RemoveContactFromSegmentOptions.builder()
        .email("steve.wozniak@gmail.com")
        .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
        .build();

      resend.contacts().segments().remove(optionsByEmail);
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.ContactRemoveFromSegmentAsync(
      contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
      segmentId: new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" )
  );
  ```

  ```bash cURL theme={null}
  // Update by contact id
  curl -X DELETE 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
       -H 'Authorization: Bearer re_xxxxxxxxx'

  // Update by contact email
  curl -X DELETE 'https://api.resend.com/contacts/steve.wozniak@gmail.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    "deleted": true
  }
  ```
</ResponseExample>


# Retrieve Contact
Source: https://resend.com/docs/api-reference/contacts/get-contact

GET /contacts/:id
Retrieve a single contact.

## Path Parameters

Either `id` or `email` must be provided.

<ParamField type="string">
  The Contact ID.
</ParamField>

<ParamField type="string">
  The Contact Email.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Get by contact id
  const { data, error } = await resend.contacts.get({
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  });

  // Get by contact email
  const { data, error } = await resend.contacts.get({
    email: 'steve.wozniak@gmail.com',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Get by contact id
  $resend->contacts->get(
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3'
  );

  // Get by contact email
  $resend->contacts->get(
    email: 'steve.wozniak@gmail.com'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  # Get by contact id
  resend.Contacts.get(
    id="e169aa45-1ecf-4183-9955-b1499d5701d3",
  )

  # Get by contact email
  resend.Contacts.get(
    email="steve.wozniak@gmail.com",
  )
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  # Get by contact id
  params = {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
  }

  Resend::Contacts.get(params)

  # Get by contact email
  params = {
    "email": "steve.wozniak@gmail.com",
  }

  Resend::Contacts.get(params)
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  // Get by contact id
  id := "e169aa45-1ecf-4183-9955-b1499d5701d3"
  contact, err := client.Contacts.Get(id)

  // Get by contact email
  email := "steve.wozniak@gmail.com"
  contact, err := client.Contacts.Get(email)
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    // Get by contact id
    let _contact = resend
      .contacts
      .get("e169aa45-1ecf-4183-9955-b1499d5701d3")
      .await?;

    // Get by contact email
    let _contact = resend
      .contacts
      .get("steve.wozniak@gmail.com")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          // Get by contact id
          GetContactOptions params = GetContactOptions.builder()
                  .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
                  .build();

          // Get by contact email
          GetContactOptions params = GetContactOptions.builder()
                  .email("steve.wozniak@gmail.com")
                  .build();

          GetContactResponseSuccess data = resend.contacts().get(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  // Get by contact id
  var resp1 = await resend.ContactRetrieveAsync(
      contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" )
  );

  // Get by contact email
  var resp2 = await resend.ContactRetrieveByEmailAsync(
      email: "steve.wozniak@gmail.com"
  );

  Console.WriteLine( "Contact Email={0}", resp2.Content.Email );
  ```

  ```bash cURL theme={null}
  # Get by contact id
  curl -X GET 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3' \
       -H 'Authorization: Bearer re_xxxxxxxxx'

  # Get by contact email
  curl -X GET 'https://api.resend.com/contacts/steve.wozniak@gmail.com' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "contact",
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
    "created_at": "2023-10-06T23:47:56.678Z",
    "unsubscribed": false,
    "properties": {
      "company_name": "Acme Corp",
      "department": "Engineering"
    }
  }
  ```
</ResponseExample>


# Retrieve Contact Topics
Source: https://resend.com/docs/api-reference/contacts/get-contact-topics

GET /contacts/:contact_id/topics
Retrieve a list of topics subscriptions for a contact.

## Path Parameters

Either `id` or `email` must be provided.

<ParamField type="string">
  The Contact ID.
</ParamField>

<ParamField type="string">
  The Contact Email.
</ParamField>

<QueryParams type="topics" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Get by contact id
  const { data, error } = await resend.contacts.topics.list({
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  });

  // Get by contact email
  const { data, error } = await resend.contacts.topics.list({
    email: 'steve.wozniak@gmail.com',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Get by contact id
  $resend->contacts->topics->get('e169aa45-1ecf-4183-9955-b1499d5701d3');

  // Get by contact email
  $resend->contacts->topics->get('steve.wozniak@gmail.com');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  # Get by contact id
  topics = resend.Contacts.Topics.list(contact_id='e169aa45-1ecf-4183-9955-b1499d5701d3')

  # Get by contact email
  topics = resend.Contacts.Topics.list(email='steve.wozniak@gmail.com')
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  # Get by contact id
  contact_topics = Resend::Contacts::Topics.list(id: "e169aa45-1ecf-4183-9955-b1499d5701d3")

  # Get by contact email
  contact_topics = Resend::Contacts::Topics.list(id: "steve.wozniak@gmail.com")
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	// Get by contact id
  	topics, err := client.Contacts.Topics.ListWithContext(ctx, &resend.ListContactTopicsRequest{
  		ContactId: "e169aa45-1ecf-4183-9955-b1499d5701d3",
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(topics)

  	// Get by contact email
  	topics, err = client.Contacts.Topics.ListWithContext(ctx, &resend.ListContactTopicsRequest{
  		Email: "steve.wozniak@gmail.com",
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(topics)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let _topics = resend
      .contacts
      .get_contact_topics(
        "e169aa45-1ecf-4183-9955-b1499d5701d3",
        ListOptions::default(),
      )
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      // Get by contact id
      resend.contacts().topics().list("e169aa45-1ecf-4183-9955-b1499d5701d3");

      // Get by contact email
      resend.contacts().topics().list("steve.wozniak@gmail.com");
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ContactListTopicsAsync( new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ));
  Console.WriteLine( "Nr Topics={0}", resp.Content.Data.Count );
  ```

  ```bash cURL theme={null}
  // Get by contact id
  curl -X GET 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/topics' \
       -H 'Authorization: Bearer re_xxxxxxxxx'

  // Get by contact email
  curl -X GET 'https://api.resend.com/contacts/steve.wozniak@gmail.com/topics' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
        "name": "Product Updates",
        "description": "New features, and latest announcements.",
        "subscription": "opt_in"
      }
    ]
  }
  ```
</ResponseExample>


# List Contact Segments
Source: https://resend.com/docs/api-reference/contacts/list-contact-segments

GET /contacts/:id/segments
Retrieve a list of segments that a contact is part of.

## Path Parameters

Either `id` or `email` must be provided.

<ParamField type="string">
  The Contact ID.
</ParamField>

<ParamField type="string">
  The Contact Email.
</ParamField>

<QueryParams type="segments" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.contacts.segments.list({
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->contacts->segments->list(
    contactId: 'e169aa45-1ecf-4183-9955-b1499d5701d3'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  params = {
      "contact_id": 'e169aa45-1ecf-4183-9955-b1499d5701d3',
  }

  segments = resend.Contacts.Segments.list(params)
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  segments = Resend::Contacts::Segments.list(
    contact_id: 'e169aa45-1ecf-4183-9955-b1499d5701d3'
  )
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	listParams := &resend.ListContactSegmentsRequest{
  		ContactId: "e169aa45-1ecf-4183-9955-b1499d5701d3",
  	}

  	segments, err := client.Contacts.Segments.ListWithContext(ctx, listParams)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(segments)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result, list_opts::ListOptions};

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

    let _contacts = resend
      .contacts
      .list_contact_segment(
        "e169aa45-1ecf-4183-9955-b1499d5701d3",
        ListOptions::default()
      )
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      resend.contacts().segments().list("e169aa45-1ecf-4183-9955-b1499d5701d3");
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ContactListSegmentsAsync( new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ));
  Console.WriteLine( "Nr Segments={0}", resp.Content.Data.Count );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/segments' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "data": [
      {
        "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
        "name": "Registered Users",
        "created_at": "2023-10-06T22:59:55.977Z"
      }
    ],
    "has_more": false
  }
  ```
</ResponseExample>


# List Contacts
Source: https://resend.com/docs/api-reference/contacts/list-contacts

GET /contacts
Show all contacts.

## Path Parameters

<ResendParamField type="string">
  The Segment ID to filter contacts by. If provided, only contacts in this Segment will be returned.
</ResendParamField>

<QueryParams type="contacts" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Contacts.list()
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Contacts.list()
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  contacts, err := client.Contacts.List()
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result, list_opts::ListOptions};

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

    let _contacts = resend
      .contacts
      .list(
          ListOptions::default(),
      )
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          ListContactsResponseSuccess data = resend.contacts().list();
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/contacts' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
        "email": "steve.wozniak@gmail.com",
        "first_name": "Steve",
        "last_name": "Wozniak",
        "created_at": "2023-10-06T23:47:56.678Z",
        "unsubscribed": false,
        "properties": {
          "company_name": "Acme Corp",
          "department": "Engineering"
        }
      }
    ]
  }
  ```
</ResponseExample>


# Update Contact
Source: https://resend.com/docs/api-reference/contacts/update-contact

PATCH /contacts/:id
Update an existing contact.

## Path Parameters

Either `id` or `email` must be provided.

<ParamField type="string">
  The Contact ID.
</ParamField>

<ParamField type="string">
  The Contact Email.
</ParamField>

## Body Parameters

<ResendParamField type="string">
  The first name of the contact.
</ResendParamField>

<ResendParamField type="string">
  The last name of the contact.
</ResendParamField>

<ParamField type="boolean">
  The Contact's global subscription status. If set to `true`, the contact will
  be unsubscribed from all Broadcasts.
</ParamField>

<ParamField type="object">
  A map of custom property keys and values to update.

  <Expandable title="custom properties">
    <ParamField type="string">
      The property key.
    </ParamField>

    <ParamField type="string">
      The property value.
    </ParamField>
  </Expandable>
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Update by contact id
  const { data, error } = await resend.contacts.update({
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    unsubscribed: true,
  });

  // Update by contact email
  const { data, error } = await resend.contacts.update({
    email: 'acme@example.com',
    unsubscribed: true,
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Update by contact id
  $resend->contacts->update(
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    parameters: [
      'unsubscribed' => true
    ]
  );

  // Update by contact email
  $resend->contacts->update(
    email: 'acme@example.com',
    parameters: [
      'unsubscribed' => true
    ]
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  # Update by contact id
  params: resend.Contacts.UpdateParams = {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "unsubscribed": True,
  }

  resend.Contacts.update(params)

  # Update by contact email
  params: resend.Contacts.UpdateParams = {
    "email": "acme@example.com",
    "unsubscribed": True,
  }

  resend.Contacts.update(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  # Update by contact id
  params = {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "unsubscribed": true,
  }

  Resend::Contacts.update(params)

  # Update by contact email
  params = {
    "email": "acme@example.com",
    "unsubscribed": true,
  }

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

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  // Update by contact id
  params := &resend.UpdateContactRequest{
    Id:           "e169aa45-1ecf-4183-9955-b1499d5701d3",
    Unsubscribed: true,
  }
  params.SetUnsubscribed(true)

  contact, err := client.Contacts.Update(params)

  // Update by contact email
  params = &resend.UpdateContactRequest{
    Email:        "acme@example.com",
    Unsubscribed: true,
  }
  params.SetUnsubscribed(true)

  contact, err := client.Contacts.Update(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::ContactChanges, Resend, Result};

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

    let changes = ContactChanges::new().with_unsubscribed(true);

    // Update by contact id
    let _contact = resend
      .contacts
      .update("e169aa45-1ecf-4183-9955-b1499d5701d3", changes.clone())
      .await?;

    // Update by contact email
    let _contact = resend
      .contacts
      .update("acme@example.com", changes)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          // Update by contact id
          UpdateContactOptions params = UpdateContactOptions.builder()
                  .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
                  .unsubscribed(true)
                  .build();

          // Update by contact email
          UpdateContactOptions params = UpdateContactOptions.builder()
                  .email("acme@example.com")
                  .unsubscribed(true)
                  .build();

          UpdateContactResponseSuccess data = resend.contacts().update(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  // By Id
  await resend.ContactUpdateAsync(
      contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
      new ContactData()
      {
          FirstName = "Stevie",
          LastName = "Wozniaks",
          IsUnsubscribed = true,
      }
  );

  // By Email
  await resend.ContactUpdateByEmailAsync(
      "acme@example.com",
      new ContactData()
      {
          FirstName = "Stevie",
          LastName = "Wozniaks",
          IsUnsubscribed = true,
      }
  );
  ```

  ```bash cURL theme={null}
  # Update by contact id
  curl -X PATCH 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "unsubscribed": true
  }'

  # Update by contact email
  curl -X PATCH 'https://api.resend.com/contacts/acme@example.com' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "unsubscribed": true
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "contact",
    "id": "479e3145-dd38-476b-932c-529ceb705947"
  }
  ```
</ResponseExample>


# Update Contact Topics
Source: https://resend.com/docs/api-reference/contacts/update-contact-topics

PATCH /contacts/:contact_id/topics
Update topic subscriptions for a contact.

## Path Parameters

Either `id` or `email` must be provided.

<ParamField type="string">
  The Contact ID.
</ParamField>

<ParamField type="string">
  The Contact Email.
</ParamField>

## Body Parameters

<ParamField type="array">
  Array of topic subscription updates.

  <Expandable title="properties">
    <ParamField type="string">
      The Topic ID.
    </ParamField>

    <ParamField type="string">
      The subscription action. Must be either `opt_in` or `opt_out`.
    </ParamField>
  </Expandable>
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Update by contact id
  const { data, error } = await resend.contacts.topics.update({
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    topics: [
      {
        id: 'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
        subscription: 'opt_out',
      },
      {
        id: '07d84122-7224-4881-9c31-1c048e204602',
        subscription: 'opt_in',
      },
    ],
  });

  // Update by contact email
  const { data, error } = await resend.contacts.topics.update({
    email: 'steve.wozniak@gmail.com',
    topics: [
      {
        id: '07d84122-7224-4881-9c31-1c048e204602',
        subscription: 'opt_out',
      },
      {
        id: '07d84122-7224-4881-9c31-1c048e204602',
        subscription: 'opt_in',
      },
    ],
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Update by contact id
  $resend->contacts->topics->update('e169aa45-1ecf-4183-9955-b1499d5701d3', [
    [
      'id' => '07d84122-7224-4881-9c31-1c048e204602',
      'subscription' => 'opt_out',
    ],
    [
      'id' => '07d84122-7224-4881-9c31-1c048e204602',
      'subscription' => 'opt_in',
    ],
  ]);

  // Update by contact email
  $resend->contacts->topics->update('steve.wozniak@gmail.com', [
    [
      'id' => '07d84122-7224-4881-9c31-1c048e204602',
      'subscription' => 'opt_out',
    ],
    [
      'id' => '07d84122-7224-4881-9c31-1c048e204602',
      'subscription' => 'opt_in',
    ],
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  # Update by contact id
  params = {
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "topics": [
          {"id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e", "subscription": "opt_out"},
          {"id": "07d84122-7224-4881-9c31-1c048e204602", "subscription": "opt_in"},
      ],
  }

  response = resend.Contacts.Topics.update(params)

  # Update by contact email
  params_by_email = {
      "email": "steve.wozniak@gmail.com",
      "topics": [
          {"id": "07d84122-7224-4881-9c31-1c048e204602", "subscription": "opt_out"},
          {"id": "07d84122-7224-4881-9c31-1c048e204602", "subscription": "opt_in"},
      ],
  }

  response = resend.Contacts.Topics.update(params_by_email)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  # Update by contact id
  update_params = {
    id: "e169aa45-1ecf-4183-9955-b1499d5701d3",
    topics: [
      { id: "b6d24b8e-af0b-4c3c-be0c-359bbd97381e", subscription: "opt_out" },
      { id: "07d84122-7224-4881-9c31-1c048e204602", subscription: "opt_in" }
    ]
  }
  updated_topics = Resend::Contacts::Topics.update(update_params)

  # Update by contact email
  update_params = {
    email: "steve.wozniak@gmail.com",
    topics: [
      { id: "07d84122-7224-4881-9c31-1c048e204602", subscription: "opt_out" },
      { id: "07d84122-7224-4881-9c31-1c048e204602", subscription: "opt_in" }
    ]
  }
  updated_topics = Resend::Contacts::Topics.update(update_params)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	// Update by contact id
  	params := &resend.UpdateContactTopicsRequest{
  		ContactId: "e169aa45-1ecf-4183-9955-b1499d5701d3",
  		Topics: []resend.TopicSubscriptionUpdate{
  			{
  				Id:           "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  				Subscription: "opt_out",
  			},
  			{
  				Id:           "07d84122-7224-4881-9c31-1c048e204602",
  				Subscription: "opt_in",
  			},
  		},
  	}

  	updatedTopics, err := client.Contacts.Topics.UpdateWithContext(ctx, params)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(updatedTopics)

  	// Update by contact email
  	params = &resend.UpdateContactTopicsRequest{
  		Email: "steve.wozniak@gmail.com",
  		Topics: []resend.TopicSubscriptionUpdate{
  			{
  				Id:           "07d84122-7224-4881-9c31-1c048e204602",
  				Subscription: "opt_out",
  			},
  			{
  				Id:           "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  				Subscription: "opt_in",
  			},
  		},
  	}

  	updatedTopics, err = client.Contacts.Topics.UpdateWithContext(ctx, params)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(updatedTopics)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    types::{SubscriptionType, UpdateContactTopicOptions},
    Resend, Result,
  };

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

    let topics = [
      UpdateContactTopicOptions::new(
        "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
        SubscriptionType::OptOut,
      ),
      UpdateContactTopicOptions::new(
        "07d84122-7224-4881-9c31-1c048e204602",
        SubscriptionType::OptIn,
      ),
    ];

    let _contact = resend
      .contacts
      .update_contact_topics("e169aa45-1ecf-4183-9955-b1499d5701d3", topics)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      // Update by contact id
      UpdateContactTopicsOptions optionsById = UpdateContactTopicsOptions.builder()
                  .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
                  .topics(ContactTopicOptions.builder()
                              .id("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
                              .subscription("opt_out")
                              .build(),
                          ContactTopicOptions.builder()
                              .id("07d84122-7224-4881-9c31-1c048e204602")
                              .subscription("opt_in")
                              .build())
                  .build();

      resend.contacts().topics().update(optionsById);

      // Update by contact email
      UpdateContactTopicsOptions optionsByEmail = UpdateContactTopicsOptions.builder()
                  .email("steve.wozniak@gmail.com")
                  .topics(ContactTopicOptions.builder()
                              .id("07d84122-7224-4881-9c31-1c048e204602")
                              .subscription("opt_in")
                              .build(),
                          ContactTopicOptions.builder()
                              .id("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
                              .subscription("opt_out")
                              .build())
                  .build();

      resend.contacts().topics().update(optionsById);
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var topics = new List<TopicSubscription>();

  topics.Add( new TopicSubscription() {
    Id = new Guid( "07d84122-7224-4881-9c31-1c048e204602" ),
    Subscription = SubscriptionType.OptIn,
  });

  topics.Add( new TopicSubscription() {
    Id = new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ),
    Subscription = SubscriptionType.OptOut,
  });

  await resend.ContactUpdateTopicsAsync(
      new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
      topics );
  ```

  ```bash cURL theme={null}
  // Update by contact id
  curl -X PATCH 'https://api.resend.com/contacts/e169aa45-1ecf-4183-9955-b1499d5701d3/topics' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'[
        {
          "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
          "subscription": "opt_out"
        }
       ]'

  // Update by contact email
  curl -X PATCH 'https://api.resend.com/contacts/steve.wozniak@gmail.com/topics' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'[
        {
          "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
          "subscription": "opt_out"
        }
       ]'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
  }
  ```
</ResponseExample>


# Create Domain
Source: https://resend.com/docs/api-reference/domains/create-domain

POST /domains
Create a domain through the Resend Email API.

## Body Parameters

<ParamField type="string">
  The name of the domain you want to create.
</ParamField>

<ParamField type="string">
  The region where emails will be sent from. Possible values: `'us-east-1' |
      'eu-west-1' | 'sa-east-1' | 'ap-northeast-1'`
</ParamField>

<ResendParamField type="string">
  For advanced use cases, choose a subdomain for the Return-Path address. The
  custom return path is used for SPF authentication, DMARC alignment, and
  handling bounced emails. Defaults to `send` (i.e., `send.yourdomain.tld`). Avoid
  setting values that could undermine credibility (e.g. `testing`), as they may
  be exposed to recipients.

  Learn more about [custom return paths](/dashboard/domains/introduction#custom-return-path).
</ResendParamField>

<ResendParamField type="boolean">
  Track the open rate of each email.
</ResendParamField>

<ResendParamField type="boolean">
  Track clicks within the body of each HTML email.
</ResendParamField>

<ParamField type="string">
  <ul>
    <li>
      `opportunistic`: Opportunistic TLS means that it always attempts to make a
      secure connection to the receiving mail server. If it can't establish a
      secure connection, it sends the message unencrypted.
    </li>

    <li>
      `enforced`: Enforced TLS on the other hand, requires that the email
      communication must use TLS no matter what. If the receiving server does
      not support TLS, the email will not be sent.
    </li>
  </ul>
</ParamField>

<ParamField type="object">
  Configure the domain capabilities for sending and receiving emails. At least one capability must be enabled.

  <Expandable title="properties">
    <ParamField type="string">
      Enable or disable sending emails from this domain. Possible values: `'enabled' | 'disabled'`
    </ParamField>

    <ParamField type="string">
      Enable or disable receiving emails to this domain. Possible values: `'enabled' | 'disabled'`
    </ParamField>
  </Expandable>
</ParamField>

<Info>
  See all available `status` types in [the Domains
  overview](/dashboard/domains/introduction#understand-a-domain-status).
</Info>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.domains.create({ name: 'example.com' });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->domains->create([
    'name' => 'example.com'
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Domains.CreateParams = {
    "name": "example.com",
  }

  resend.Domains.create(params)
  ```

  ```ruby Ruby theme={null}
  Resend.api_key = ENV["RESEND_API_KEY"]

  params = {
    name: "example.com",
  }
  domain = Resend::Domains.create(params)
  puts domain
  ```

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateDomainRequest{
      Name: "example.com",
  }

  domain, err := client.Domains.Create(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::CreateDomainOptions, Resend, Result};

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

    let _domain = resend
      .domains
      .add(CreateDomainOptions::new("example.com"))
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          CreateDomainOptions params = CreateDomainOptions
                  .builder()
                  .name("example.com").build();

          CreateDomainResponse domain = resend.domains().create(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.DomainAddAsync( "example.com" );
  Console.WriteLine( "Domain Id={0}", resp.Content.Id );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/domains' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "example.com"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
    "name": "example.com",
    "created_at": "2023-03-28T17:12:02.059593+00:00",
    "status": "not_started",
    "capabilities": {
      "sending": "enabled",
      "receiving": "disabled"
    },
    "records": [
      {
        "record": "SPF",
        "name": "send",
        "type": "MX",
        "ttl": "Auto",
        "status": "not_started",
        "value": "feedback-smtp.us-east-1.amazonses.com",
        "priority": 10
      },
      {
        "record": "SPF",
        "name": "send",
        "value": "\"v=spf1 include:amazonses.com ~all\"",
        "type": "TXT",
        "ttl": "Auto",
        "status": "not_started"
      },
      {
        "record": "DKIM",
        "name": "nhapbbryle57yxg3fbjytyodgbt2kyyg._domainkey",
        "value": "nhapbbryle57yxg3fbjytyodgbt2kyyg.dkim.amazonses.com.",
        "type": "CNAME",
        "status": "not_started",
        "ttl": "Auto"
      },
      {
        "record": "DKIM",
        "name": "xbakwbe5fcscrhzshpap6kbxesf6pfgn._domainkey",
        "value": "xbakwbe5fcscrhzshpap6kbxesf6pfgn.dkim.amazonses.com.",
        "type": "CNAME",
        "status": "not_started",
        "ttl": "Auto"
      },
      {
        "record": "DKIM",
        "name": "txrcreso3dqbvcve45tqyosxwaegvhgn._domainkey",
        "value": "txrcreso3dqbvcve45tqyosxwaegvhgn.dkim.amazonses.com.",
        "type": "CNAME",
        "status": "not_started",
        "ttl": "Auto"
      }
    ],
    "region": "us-east-1"
  }
  ```
</ResponseExample>


# Delete Domain
Source: https://resend.com/docs/api-reference/domains/delete-domain

DELETE /domains/:domain_id
Remove an existing domain.

## Path Parameters

<ResendParamField type="string">
  The Domain ID.
</ResendParamField>

<RequestExample>
  ```js Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.domains.remove(
    'd91cd9bd-1176-453e-8fc1-35364d380206',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->domains->remove('d91cd9bd-1176-453e-8fc1-35364d380206');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Domains.remove(domain_id="d91cd9bd-1176-453e-8fc1-35364d380206")
  ```

  ```ruby Ruby theme={null}
  Resend.api_key = ENV["RESEND_API_KEY"]
  Resend::Domains.remove("d91cd9bd-1176-453e-8fc1-35364d380206")
  ```

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  removed, err := client.Domains.Remove("d91cd9bd-1176-453e-8fc1-35364d380206")
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _deleted = resend
      .domains
      .delete("d91cd9bd-1176-453e-8fc1-35364d380206")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          RemoveDomainResponse removed = resend.domains().remove("d91cd9bd-1176-453e-8fc1-35364d380206");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.DomainDeleteAsync( new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ) );
  ```

  ```bash cURL theme={null}
  curl -X DELETE 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "domain",
    "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
    "deleted": true
  }
  ```
</ResponseExample>


# Retrieve Domain
Source: https://resend.com/docs/api-reference/domains/get-domain

GET /domains/:domain_id
Retrieve a single domain for the authenticated user.

## Path Parameters

<ResendParamField type="string">
  The Domain ID.
</ResendParamField>

<Info>
  See all available `status` types in [the Domains
  overview](/dashboard/domains/introduction#understand-a-domain-status).
</Info>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.domains.get(
    'd91cd9bd-1176-453e-8fc1-35364d380206',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->domains->get('d91cd9bd-1176-453e-8fc1-35364d380206');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Domains.get(domain_id="d91cd9bd-1176-453e-8fc1-35364d380206")
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Domains.get "d91cd9bd-1176-453e-8fc1-35364d380206"
  ```

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  retrievedDomain, err := client.Domains.Get("d91cd9bd-1176-453e-8fc1-35364d380206")
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _domain = resend
      .domains
      .get("d91cd9bd-1176-453e-8fc1-35364d380206")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          Domain domain = resend.domains().get("d91cd9bd-1176-453e-8fc1-35364d380206");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.DomainRetrieveAsync( new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ) );
  Console.WriteLine( "Domain Id={0}", resp.Content.Name );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "domain",
    "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
    "name": "example.com",
    "status": "not_started",
    "created_at": "2023-04-26T20:21:26.347412+00:00",
    "region": "us-east-1",
    "capabilities": {
      "sending": "enabled",
      "receiving": "disabled"
    },
    "records": [
      {
        "record": "SPF",
        "name": "send",
        "type": "MX",
        "ttl": "Auto",
        "status": "not_started",
        "value": "feedback-smtp.us-east-1.amazonses.com",
        "priority": 10
      },
      {
        "record": "SPF",
        "name": "send",
        "value": "\"v=spf1 include:amazonses.com ~all\"",
        "type": "TXT",
        "ttl": "Auto",
        "status": "not_started"
      },
      {
        "record": "DKIM",
        "name": "resend._domainkey",
        "value": "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsc4Lh8xilsngyKEgN2S84+21gn+x6SEXtjWvPiAAmnmggr5FWG42WnqczpzQ/mNblqHz4CDwUum6LtY6SdoOlDmrhvp5khA3cd661W9FlK3yp7+jVACQElS7d9O6jv8VsBbVg4COess3gyLE5RyxqF1vYsrEXqyM8TBz1n5AGkQIDAQA2",
        "type": "TXT",
        "status": "not_started",
        "ttl": "Auto"
      }
    ]
  }
  ```
</ResponseExample>


# List Domains
Source: https://resend.com/docs/api-reference/domains/list-domains

GET /domains
Retrieve a list of domains for the authenticated user.

<Info>
  See all available `status` types in [the Domains
  overview](/dashboard/domains/introduction#understand-a-domain-status).
</Info>

<QueryParams type="domains" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

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

  ```ruby Ruby theme={null}
  Resend.api_key = ENV["RESEND_API_KEY"]
  Resend::Domains.list
  ```

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  domains, err := client.Domains.List()
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result, list_opts::ListOptions};

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

    let _domains = resend.domains.list(ListOptions::default()).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          ListDomainsResponse response = resend.domains().list();
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/domains' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
        "name": "example.com",
        "status": "not_started",
        "created_at": "2023-04-26T20:21:26.347412+00:00",
        "region": "us-east-1",
        "capabilities": {
          "sending": "enabled",
          "receiving": "disabled"
        }
      }
    ]
  }
  ```
</ResponseExample>


# Update Domain
Source: https://resend.com/docs/api-reference/domains/update-domain

PATCH /domains/:domain_id
Update an existing domain.

## Path Parameters

<ResendParamField type="string">
  The Domain ID.
</ResendParamField>

## Body Parameters

<ResendParamField type="boolean">
  Track clicks within the body of each HTML email.
</ResendParamField>

<ResendParamField type="boolean">
  Track the open rate of each email.
</ResendParamField>

<ParamField type="string">
  <ul>
    <li>
      `opportunistic`: Opportunistic TLS means that it always attempts to make a
      secure connection to the receiving mail server. If it can't establish a
      secure connection, it sends the message unencrypted.
    </li>

    <li>
      `enforced`: Enforced TLS on the other hand, requires that the email
      communication must use TLS no matter what. If the receiving server does
      not support TLS, the email will not be sent.
    </li>
  </ul>
</ParamField>

<ParamField type="object">
  Update the domain capabilities for sending and receiving emails. You can specify one or both fields. Omitted fields will keep their current value. At least one capability must remain enabled.

  <Expandable title="properties">
    <ParamField type="string">
      Enable or disable sending emails from this domain. Possible values: `'enabled' | 'disabled'`
    </ParamField>

    <ParamField type="string">
      Enable or disable receiving emails to this domain. Possible values: `'enabled' | 'disabled'`
    </ParamField>
  </Expandable>
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.domains.update({
    id: 'b8617ad3-b712-41d9-81a0-f7c3d879314e',
    openTracking: false,
    clickTracking: true,
    tls: 'enforced',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->domains->update(
    'b8617ad3-b712-41d9-81a0-f7c3d879314e',
    [
      'open_tracking' => false,
      'click_tracking' => true,
      'tls' => 'enforced',
    ]
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Domains.UpdateParams = {
    "id": "b8617ad3-b712-41d9-81a0-f7c3d879314e",
    "open_tracking": False,
    "click_tracking": True,
    "tls": "enforced",
  }

  resend.Domains.update(params)
  ```

  ```ruby Ruby theme={null}
  Resend.api_key = "re_xxxxxxxxx"

  Resend::Domains.update({
    id: "b8617ad3-b712-41d9-81a0-f7c3d879314e",
    open_tracking: false,
    click_tracking: true,
    tls: "enforced",
  })
  ```

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  updateDomainParams := &resend.UpdateDomainRequest{
    OpenTracking:  false,
    ClickTracking: true,
    Tls: resend.Enforced,
  }

  updated, err := client.Domains.Update("b8617ad3-b712-41d9-81a0-f7c3d879314e", updateDomainParams)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::{DomainChanges, Tls}, Resend, Result};

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

    let changes = DomainChanges::new()
      .with_open_tracking(false)
      .with_click_tracking(true)
      .with_tls(Tls::Enforced);

    let _domain = resend
      .domains
      .update("b8617ad3-b712-41d9-81a0-f7c3d879314e", changes)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

  UpdateDomainOptions params = UpdateDomainOptions.builder()
                  .id("b8617ad3-b712-41d9-81a0-f7c3d879314e")
                  .openTracking(false)
                  .clickTracking(true)
                  .tls(Tls.ENFORCED)
                  .build();

  resend.domains().update(params);
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.DomainUpdateAsync(
      new Guid( "b8617ad3-b712-41d9-81a0-f7c3d879314e" ),
      new DomainUpdateData()
      {
          TrackOpen = false,
          TrackClicks = true,
          TlsMode = TlsMode.Enforced,
      }
  );
  ```

  ```bash cURL theme={null}
  curl -X PATCH 'https://api.resend.com/domains/b8617ad3-b712-41d9-81a0-f7c3d879314e' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "open_tracking": false,
    "click_tracking": true,
    "tls": "enforced"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "domain",
    "id": "b8617ad3-b712-41d9-81a0-f7c3d879314e"
  }
  ```
</ResponseExample>


# Verify Domain
Source: https://resend.com/docs/api-reference/domains/verify-domain

POST /domains/:domain_id/verify
Verify an existing domain.

## Path Parameters

<ResendParamField type="string">
  The Domain ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.domains.verify(
    'd91cd9bd-1176-453e-8fc1-35364d380206',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->domains->verify('d91cd9bd-1176-453e-8fc1-35364d380206');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"
  resend.Domains.verify(domain_id="d91cd9bd-1176-453e-8fc1-35364d380206")
  ```

  ```ruby Ruby theme={null}
  Resend.api_key = ENV["RESEND_API_KEY"]
  Resend::Domains.verify("d91cd9bd-1176-453e-8fc1-35364d380206")
  ```

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  verified, err := client.Domains.Verify("d91cd9bd-1176-453e-8fc1-35364d380206")
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    resend
      .domains
      .verify("d91cd9bd-1176-453e-8fc1-35364d380206")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          VerifyDomainResponse verified = resend.domains().verify("d91cd9bd-1176-453e-8fc1-35364d380206");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.DomainVerifyAsync( new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ) );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/domains/d91cd9bd-1176-453e-8fc1-35364d380206/verify' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "domain",
    "id": "d91cd9bd-1176-453e-8fc1-35364d380206"
  }
  ```
</ResponseExample>


# Cancel Email
Source: https://resend.com/docs/api-reference/emails/cancel-email

POST /emails/:id/cancel
Cancel a scheduled email.

## Path Parameters

<ParamField type="string">
  The Email ID.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.emails.cancel(
    '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->cancel('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"
  resend.Emails.cancel(email_id="49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Emails.cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  canceled, err := client.Emails.Cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
  if err != nil {
    panic(err)
  }
  fmt.Println(canceled.Id)
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _canceled = resend
      .emails
      .cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          CancelEmailResponse canceled = resend
            .emails()
            .cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.EmailCancelAsync( new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ) );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/emails/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794/cancel' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "email",
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
  }
  ```
</ResponseExample>


# List Attachments
Source: https://resend.com/docs/api-reference/emails/list-email-attachments

GET /emails/:email_id/attachments
Retrieve a list of attachments from a sent email.

<QueryParams type="attachments" />

## Path Parameters

<ParamField type="string">
  The Email ID.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.emails.attachments.list({
    emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->attachments->list(
    emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  attachments = resend.Emails.Attachments.list(
    email_id='4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
  )
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  Resend::Emails::Attachments.list(
    email_id: "4ef9a417-02e9-4d39-ad75-9611e0fcc33c"
  )
  ```

  ```go Go theme={null}
  import (
  	"context"
  	"github.com/resend/resend-go/v3"
  )

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

  	attachments, err := client.Emails.ListAttachmentsWithContext(
  		context.TODO(),
  		"4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let _email = resend
      .emails
      .list_attachments(
        "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
        ListOptions::default(),
      )
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      ListAttachmentsResponse response = resend.emails().listAttachments(
        "4ef9a417-02e9-4d39-ad75-9611e0fcc33c"
      );
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.EmailAttachmentListAsync( new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ));
  Console.WriteLine( "Nr Attachments={0}", resp.Content.Data.Count );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/emails/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
        "filename": "avatar.png",
        "size": 4096,
        "content_type": "image/png",
        "content_disposition": "inline",
        "content_id": "img001",
        "download_url": "https://outbound-cdn.resend.com/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318?some-params=example&signature=sig-123",
        "expires_at": "2025-10-17T14:29:41.521Z"
      }
    ]
  }
  ```
</ResponseExample>


# List Sent Emails
Source: https://resend.com/docs/api-reference/emails/list-emails

GET /emails
Retrieve a list of emails sent by your team.

You can list all emails sent by your team. The list returns references to individual emails. If needed, you can use the `id` of an email to retrieve the email HTML to plain text using the [Retrieve Email](/api-reference/emails/retrieve-email) endpoint or the [Retrieve Attachments](/api-reference/emails/list-email-attachments) endpoint to get an email's attachments.

<Info>
  This endpoint only returns emails sent by your team. If you need to list
  emails received by your domain, use the [List Received
  Emails](/api-reference/emails/list-received-emails) endpoint.
</Info>

<QueryParams type="emails" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

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

  ```ruby Ruby theme={null}
  Resend.api_key = "re_xxxxxxxxx"
  emails = Resend::Emails.list
  puts emails
  ```

  ```go Go theme={null}
  import (
    "context"
    "fmt"

    "github.com/resend/resend-go/v3"
  )

  ctx := context.TODO()
  client := resend.NewClient("re_xxxxxxxxx")

  paginatedResp, err := client.Emails.ListWithOptions(ctx, nil)
  if err != nil {
    panic(err)
  }

  fmt.Printf("Found %d emails\n", len(paginatedResp.Data))

  if paginatedResp.HasMore {
    opts := &resend.ListOptions{
      After: &paginatedResp.Data[len(paginatedResp.Data)-1].ID,
    }
    paginatedResp, err = client.Emails.ListWithOptions(ctx, opts)

    if err != nil {
      panic(err)
    }

    fmt.Printf("Found %d more emails in next page\n", len(paginatedResp.Data))
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let _emails = resend.emails.list(ListOptions::default()).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          ListEmailsResponseSuccess emails = resend.emails().list();
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
        "to": ["delivered@resend.dev"],
        "from": "Acme <onboarding@resend.dev>",
        "created_at": "2023-04-03T22:13:42.674981+00:00",
        "subject": "Hello World",
        "bcc": null,
        "cc": null,
        "reply_to": null,
        "last_event": "delivered",
        "scheduled_at": null
      },
      {
        "id": "3a9f8c2b-1e5d-4f8a-9c7b-2d6e5f8a9c7b",
        "to": ["user@example.com"],
        "from": "Acme <onboarding@resend.dev>",
        "created_at": "2023-04-03T21:45:12.345678+00:00",
        "subject": "Welcome to Acme",
        "bcc": null,
        "cc": null,
        "reply_to": null,
        "last_event": "opened",
        "scheduled_at": null
      }
    ]
  }
  ```
</ResponseExample>


# List Attachments
Source: https://resend.com/docs/api-reference/emails/list-received-email-attachments

GET /emails/receiving/:email_id/attachments
Retrieve a list of attachments from a received email.

<QueryParams type="attachments" />

## Path Parameters

<ParamField type="string">
  The Email ID.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.emails.receiving.attachments.list({
    emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->receiving->attachments->list(
    emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  attachments = resend.Emails.Receiving.Attachments.list(
    email_id='4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
  )
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  attachments = Resend::Emails::Receiving::Attachments.list(
    email_id: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
  )
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	attachments, err := client.Emails.Receiving.ListAttachmentsWithContext(
  		context.TODO(),
  		"4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let _email = resend
      .receiving
      .list_attachments(
        "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
        ListOptions::default(),
      )
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      ListAttachmentsResponse response = resend.receiving().listAttachments(
        "4ef9a417-02e9-4d39-ad75-9611e0fcc33c"
      );
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ReceivedEmailAttachmentListAsync( new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ));
  Console.WriteLine( "Nr Attachments={0}", resp.Content.Data.Count );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/emails/receiving/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
        "filename": "avatar.png",
        "size": 4096,
        "content_type": "image/png",
        "content_disposition": "inline",
        "content_id": "img001",
        "download_url": "https://inbound-cdn.resend.com/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318?some-params=example&signature=sig-123",
        "expires_at": "2025-10-17T14:29:41.521Z"
      }
    ]
  }
  ```
</ResponseExample>


# List Received Emails
Source: https://resend.com/docs/api-reference/emails/list-received-emails

GET /emails/receiving
Retrieve a list of received emails for the authenticated user.

You can list all emails received by your team. The list returns references to individual emails. If needed, you can use the `id` of an email to retrieve the email HTML to plain text using the [Retrieve Received Email](/api-reference/emails/retrieve-received-email) endpoint or the [Retrieve Received Attachment](/api-reference/emails/retrieve-received-email-attachment) endpoint to get an email's attachments.

<Info>
  This endpoint only returns emails received by your team. If you need to list
  emails sent by your team, use the [List Sent
  Emails](/api-reference/emails/list-emails) endpoint.
</Info>

<QueryParams type="emails" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->receiving->list();
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Emails.Receiving.list()
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Emails::Receiving.list()
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	emails, err := client.Emails.Receiving.ListWithContext(context.TODO())
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let _email = resend.receiving.list(ListOptions::default()).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      ListReceivedEmailsResponse response = resend.receiving().list();
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/emails/receiving' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": true,
    "data": [
      {
        "id": "a39999a6-88e3-48b1-888b-beaabcde1b33",
        "to": ["recipient@example.com"],
        "from": "sender@example.com",
        "created_at": "2025-10-09 14:37:40.951732+00",
        "subject": "Hello World",
        "bcc": [],
        "cc": [],
        "reply_to": [],
        "message_id": "<111-222-333@email.provider.example.com>",
        "attachments": [
          {
            "filename": "example.txt",
            "content_type": "text/plain",
            "content_id": null,
            "content_disposition": "attachment",
            "id": "47e999c7-c89c-4999-bf32-aaaaa1c3ff21",
            "size": 13
          }
        ]
      }
    ]
  }
  ```
</ResponseExample>


# Retrieve Email
Source: https://resend.com/docs/api-reference/emails/retrieve-email

GET /emails/:id
Retrieve a single email.

## Path Parameters

<ParamField type="string">
  The Email ID.
</ParamField>

<Info>
  See all available `last_event` types in [the Email Events
  overview](/dashboard/emails/introduction#understand-email-events).
</Info>

<RequestExample>
  ```js Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.emails.get(
    '37e4414c-5e25-4dbc-a071-43552a4bd53b',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->get('37e4414c-5e25-4dbc-a071-43552a4bd53b');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"
  resend.Emails.get(email_id="4ef9a417-02e9-4d39-ad75-9611e0fcc33c")
  ```

  ```ruby Ruby theme={null}
  Resend.api_key = "re_xxxxxxxxx"
  email = Resend::Emails.get("4ef9a417-02e9-4d39-ad75-9611e0fcc33c")
  puts email
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  email, err := client.Emails.Get("4ef9a417-02e9-4d39-ad75-9611e0fcc33c")
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _email = resend
      .emails
      .get("4ef9a417-02e9-4d39-ad75-9611e0fcc33c")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          Email email = resend.emails().get("4ef9a417-02e9-4d39-ad75-9611e0fcc33c");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.EmailRetrieveAsync( new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ) );
  Console.WriteLine( "Subject={0}", resp.Content.Subject );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/emails/4ef9a417-02e9-4d39-ad75-9611e0fcc33c' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "email",
    "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
    "to": ["delivered@resend.dev"],
    "from": "Acme <onboarding@resend.dev>",
    "created_at": "2023-04-03T22:13:42.674981+00:00",
    "subject": "Hello World",
    "html": "Congrats on sending your <strong>first email</strong>!",
    "text": null,
    "bcc": [],
    "cc": [],
    "reply_to": [],
    "last_event": "delivered",
    "scheduled_at": null,
    "tags": [
      {
        "name": "category",
        "value": "confirm_email"
      }
    ]
  }
  ```
</ResponseExample>


# Retrieve Attachment
Source: https://resend.com/docs/api-reference/emails/retrieve-email-attachment

GET /emails/:email_id/attachments/:id
Retrieve a single attachment from a sent email.

## Path Parameters

<ParamField type="string">
  The Attachment ID.
</ParamField>

<ParamField type="string">
  The Email ID.
</ParamField>

<RequestExample>
  ```js Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.emails.attachments.get({
    id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
    emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->attachments->get(
    id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
    emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  attachment = resend.Emails.Attachments.get(
    email_id='4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
    attachment_id='2a0c9ce0-3112-4728-976e-47ddcd16a318'
  )
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  Resend::Emails::Attachments.get(
    id: "2a0c9ce0-3112-4728-976e-47ddcd16a318",
    email_id: "4ef9a417-02e9-4d39-ad75-9611e0fcc33c"
  )
  ```

  ```go Go theme={null}
  import (
  	"context"
  	"github.com/resend/resend-go/v3"
  )

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

  	attachment, err := client.Emails.GetAttachmentWithContext(
  		context.TODO(),
  		"4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
  		"2a0c9ce0-3112-4728-976e-47ddcd16a318",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _email = resend
      .emails
      .get_attachment(
        "2a0c9ce0-3112-4728-976e-47ddcd16a318",
        "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      )
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      AttachmentResponse attachment = resend.emails().getAttachment(
        "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
        "2a0c9ce0-3112-4728-976e-47ddcd16a318"
      );
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.EmailAttachmentRetrieveAsync(
    emailId: new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ),
    attachmentId: new Guid( "2a0c9ce0-3112-4728-976e-47ddcd16a318" )
  );
  Console.WriteLine( "URL={0}", resp.Content.DownloadUrl );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/emails/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "attachment",
    "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
    "filename": "avatar.png",
    "size": 4096,
    "content_type": "image/png",
    "content_disposition": "inline",
    "content_id": "img001",
    "download_url": "https://outbound-cdn.resend.com/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318?some-params=example&signature=sig-123",
    "expires_at": "2025-10-17T14:29:41.521Z"
  }
  ```
</ResponseExample>


# Retrieve Received Email
Source: https://resend.com/docs/api-reference/emails/retrieve-received-email

GET /emails/receiving/:id
Retrieve a single received email.

## Path Parameters

<ParamField type="string">
  The ID for the received email.
</ParamField>

<RequestExample>
  ```js Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.emails.receiving.get(
    '37e4414c-5e25-4dbc-a071-43552a4bd53b',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->receiving->get('37e4414c-5e25-4dbc-a071-43552a4bd53b');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Emails.Receiving.get(email_id="37e4414c-5e25-4dbc-a071-43552a4bd53b")
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Emails::Receiving.get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	email, err := client.Emails.Receiving.GetWithContext(
  		context.TODO(),
  		"37e4414c-5e25-4dbc-a071-43552a4bd53b",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _email = resend
      .receiving
      .get("37e4414c-5e25-4dbc-a071-43552a4bd53b")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      ReceivedEmail email = resend.receiving().get("37e4414c-5e25-4dbc-a071-43552a4bd53b");
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ReceivedEmailRetrieveAsync( new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ) );
  Console.WriteLine( "Subject={0}", resp.Content.Subject );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/emails/receiving/4ef9a417-02e9-4d39-ad75-9611e0fcc33c' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "email",
    "id": "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
    "to": ["delivered@resend.dev"],
    "from": "Acme <onboarding@resend.dev>",
    "created_at": "2023-04-03T22:13:42.674981+00:00",
    "subject": "Hello World",
    "html": "Congrats on sending your <strong>first email</strong>!",
    "text": null,
    "headers": {
      "return-path": "lucas.costa@resend.com",
      "mime-version": "1.0"
    },
    "bcc": [],
    "cc": [],
    "reply_to": [],
    "message_id": "<example+123>",
    "attachments": [
      {
        "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
        "filename": "avatar.png",
        "content_type": "image/png",
        "content_disposition": "inline",
        "content_id": "img001"
      }
    ]
  }
  ```
</ResponseExample>


# Retrieve Attachment
Source: https://resend.com/docs/api-reference/emails/retrieve-received-email-attachment

GET /emails/receiving/:email_id/attachments/:id
Retrieve a single attachment from a received email.

## Path Parameters

<ParamField type="string">
  The Attachment ID.
</ParamField>

<ParamField type="string">
  The Email ID.
</ParamField>

<RequestExample>
  ```js Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.emails.receiving.attachments.get({
    id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
    emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->receiving->attachments->get(
    id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
    emailId: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  attachment = resend.Emails.Receiving.Attachments.get(
    email_id='4ef9a417-02e9-4d39-ad75-9611e0fcc33c',
    attachment_id='2a0c9ce0-3112-4728-976e-47ddcd16a318'
  )
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  attachment = Resend::Emails::Receiving::Attachments.get(
    id: '2a0c9ce0-3112-4728-976e-47ddcd16a318',
    email_id: '4ef9a417-02e9-4d39-ad75-9611e0fcc33c'
  )
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	attachment, err := client.Emails.Receiving.GetAttachmentWithContext(
  		context.TODO(),
  		"4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
  		"2a0c9ce0-3112-4728-976e-47ddcd16a318",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _email = resend
      .receiving
      .get_attachment(
        "2a0c9ce0-3112-4728-976e-47ddcd16a318",
        "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
      )
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      AttachmentDetails attachment = resend.receiving().getAttachment(
        "4ef9a417-02e9-4d39-ad75-9611e0fcc33c",
        "2a0c9ce0-3112-4728-976e-47ddcd16a318"
      );
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ReceivedEmailAttachmentRetrieveAsync(
    emailId: new Guid( "4ef9a417-02e9-4d39-ad75-9611e0fcc33c" ),
    attachmentId: new Guid( "2a0c9ce0-3112-4728-976e-47ddcd16a318" )
  );
  Console.WriteLine( "URL={0}", resp.Content.DownloadUrl );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/emails/receiving/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "attachment",
    "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
    "filename": "avatar.png",
    "size": 4096,
    "content_type": "image/png",
    "content_disposition": "inline",
    "content_id": "img001",
    "download_url": "https://inbound-cdn.resend.com/4ef9a417-02e9-4d39-ad75-9611e0fcc33c/attachments/2a0c9ce0-3112-4728-976e-47ddcd16a318?some-params=example&signature=sig-123",
    "expires_at": "2025-10-17T14:29:41.521Z"
  }
  ```
</ResponseExample>


# Send Batch Emails
Source: https://resend.com/docs/api-reference/emails/send-batch-emails

POST /emails/batch
Trigger up to 100 batch emails at once.

Instead of sending one email per HTTP request, we provide a batching endpoint that permits you to send up to 100 emails in a single API call.

## Body Parameters

<ParamField type="string">
  Sender email address.

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

<ParamField type="string | string[]">
  Recipient email address. For multiple addresses, send as an array of strings.
  Max 50.
</ParamField>

<ParamField type="string">
  Email subject.
</ParamField>

<ParamField type="string | string[]">
  Bcc recipient email address. For multiple addresses, send as an array of
  strings.
</ParamField>

<ParamField type="string | string[]">
  Cc recipient email address. For multiple addresses, send as an array of
  strings.
</ParamField>

<ResendParamField type="string | string[]">
  Reply-to email address. For multiple addresses, send as an array of strings.
</ResendParamField>

<ParamField type="string">
  The HTML version of the message.
</ParamField>

<ParamField type="string">
  The plain text version of the message.

  <Info>
    If not provided, the HTML will be used to generate a plain text version. You
    can opt out of this behavior by setting value to an empty string.
  </Info>
</ParamField>

<ParamField type="React.ReactNode">
  The React component used to write the message. *Only available in the Node.js
  SDK.*
</ParamField>

<ParamField type="object">
  Custom headers to add to the email.
</ParamField>

<ResendParamField type="string">
  The topic ID to receive the email.

  * If the recipient is a contact and has opted-in to the topic, the email is sent.
  * If the recipient is a contact and has opted-out of the topic, the email is not sent and an error is returned.
  * If the recipient is not a contact, the email is sent if the topic default subscription value is set to `opt-in`.

  <Note>Each email address (to, cc, bcc) is checked and handled separately.</Note>
</ResendParamField>

<ParamField type="array">
  Custom data passed in key/value pairs.

  [See examples](/dashboard/emails/tags).

  <Expandable title="properties">
    <ParamField type="string">
      The name of the email tag.

      It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (\_), or dashes (-).

      It can contain no more than 256 characters.
    </ParamField>

    <ParamField type="string">
      The value of the email tag.

      It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (\_), or dashes (-).

      It can contain no more than 256 characters.
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type="object">
  To send using a template, provide a `template` object with:

  * `id`: the id *or* the alias of the published template
  * `variables`: an object with a key for each variable (if applicable)

  <Info>
    If a `template` is provided, you cannot send `html`, `text`, or `react` in the payload, otherwise the API will return a validation error.

    When sending a template, the payload for `from`, `subject`, and `reply_to` take precedence over the template's defaults for these fields. If the template does not provide a default value for these fields, you must provide them in the payload.
  </Info>
</ParamField>

<ParamField type="string">
  The id of the published email template. Required if `template` is provided. Only published templates can be used when sending emails.
</ParamField>

<ParamField type="object">
  Template variables object with key/value pairs.

  ```ts theme={null}
  variables: {
  	CTA: 'Sign up now',
  	CTA_LINK: 'https://example.com/signup'
  }
  ```

  When sending the template, the HTML will be parsed. If all the variables used in the template were provided, the email will be sent. If not, the call will throw a validation error.

  See the [errors reference](/api-reference/errors) for more details or [learn more about templates](/dashboard/templates/introduction).

  <Expandable title="properties">
    <ParamField type="string">
      The key of the variable.

      May only contain ASCII letters (a–z, A–Z), numbers (0–9), and underscores (\_). The following variable names are reserved and cannot be used: `FIRST_NAME`, `LAST_NAME`, `EMAIL`, `UNSUBSCRIBE_URL`.

      It can contain no more than 50 characters.
    </ParamField>

    <ParamField>
      The value of the variable.

      Observe these technical limitations:

      * `string`: maximum length of 2,000 characters
      * `number`: not greater than 2^53 - 1
    </ParamField>
  </Expandable>
</ParamField>

## Headers

<ParamField type="string">
  Add an idempotency key to prevent duplicated emails.

  * Should be **unique per API request**
  * Idempotency keys expire after **24 hours**
  * Have a maximum length of **256 characters**

  [Learn more about idempotency keys →](/dashboard/emails/idempotency-keys)
</ParamField>

## Limitations

The `attachments` and `scheduled_at` fields are not supported yet.

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.batch.send([
    {
      from: 'Acme <onboarding@resend.dev>',
      to: ['foo@gmail.com'],
      subject: 'hello world',
      html: '<h1>it works!</h1>',
    },
    {
      from: 'Acme <onboarding@resend.dev>',
      to: ['bar@outlook.com'],
      subject: 'world hello',
      html: '<p>it works!</p>',
    },
  ]);
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->batch->send([
    [
      'from' => 'Acme <onboarding@resend.dev>',
      'to' => ['foo@gmail.com'],
      'subject' => 'hello world',
      'html' => '<h1>it works!</h1>',
    ],
    [
      'from' => 'Acme <onboarding@resend.dev>',
      'to' => ['bar@outlook.com'],
      'subject' => 'world hello',
      'html' => '<p>it works!</p>',
    ]
  ]);
  ```

  ```py Python theme={null}
  import resend
  from typing import List

  resend.api_key = "re_xxxxxxxxx"

  params: List[resend.Emails.SendParams] = [
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["foo@gmail.com"],
      "subject": "hello world",
      "html": "<h1>it works!</h1>",
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["bar@outlook.com"],
      "subject": "world hello",
      "html": "<p>it works!</p>",
    }
  ]

  resend.Batch.send(params)
  ```

  ```rb Ruby theme={null}
  require "resend"

  Resend.api_key = 're_xxxxxxxxx'

  params = [
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["foo@gmail.com"],
      "subject": "hello world",
      "html": "<h1>it works!</h1>",
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["bar@outlook.com"],
      "subject": "world hello",
      "html": "<p>it works!</p>",
    }
  ]

  Resend::Batch.send(params)
  ```

  ```go Go theme={null}
  package examples

  import (
  	"fmt"
  	"os"

  	"github.com/resend/resend-go/v3"
  )

  func main() {

    ctx := context.TODO()

    client := resend.NewClient("re_xxxxxxxxx")

    var batchEmails = []*resend.SendEmailRequest{
      {
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"foo@gmail.com"},
        Subject: "hello world",
        Html:    "<h1>it works!</h1>",
      },
      {
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"bar@outlook.com"},
        Subject: "world hello",
        Html:    "<p>it works!</p>",
      },
    }

    sent, err := client.Batch.SendWithContext(ctx, batchEmails)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Data)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::types::CreateEmailBaseOptions;
  use resend_rs::{Resend, Result};

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

    let emails = vec![
      CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        vec!["foo@gmail.com"],
        "hello world",
      )
      .with_html("<h1>it works!</h1>"),
      CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        vec!["bar@outlook.com"],
        "world hello",
      )
      .with_html("<p>it works!</p>"),
    ];

    let _emails = resend.batch.send(emails).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          CreateEmailOptions firstEmail = CreateEmailOptions.builder()
              .from("Acme <onboarding@resend.dev>")
              .to("foo@gmail.com")
              .subject("hello world")
              .html("<h1>it works!</h1>")
              .build();

          CreateEmailOptions secondEmail = CreateEmailOptions.builder()
              .from("Acme <onboarding@resend.dev>")
              .to("bar@outlook.com")
              .subject("world hello")
              .html("<p>it works!</p>")
              .build();

          CreateBatchEmailsResponse data = resend.batch().send(
              Arrays.asList(firstEmail, secondEmail)
          );
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var mail1 = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "foo@gmail.com",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
  };

  var mail2 = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "bar@outlook.com",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
  };

  var resp = await resend.EmailBatchAsync( [ mail1, mail2 ] );
  Console.WriteLine( "Nr Emails={0}", resp.Content.Count );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/emails/batch' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'[
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["foo@gmail.com"],
      "subject": "hello world",
      "html": "<h1>it works!</h1>"
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["bar@outlook.com"],
      "subject": "world hello",
      "html": "<p>it works!</p>"
    }
  ]'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "data": [
      {
        "id": "ae2014de-c168-4c61-8267-70d2662a1ce1"
      },
      {
        "id": "faccb7a5-8a28-4e9a-ac64-8da1cc3bc1cb"
      }
    ]
  }
  ```
</ResponseExample>


# Send Email
Source: https://resend.com/docs/api-reference/emails/send-email

POST /emails
Start sending emails through the Resend Email API.

## Body Parameters

<ParamField type="string">
  Sender email address.

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

<ParamField type="string | string[]">
  Recipient email address. For multiple addresses, send as an array of strings.
  Max 50.
</ParamField>

<ParamField type="string">
  Email subject.
</ParamField>

<ParamField type="string | string[]">
  Bcc recipient email address. For multiple addresses, send as an array of
  strings.
</ParamField>

<ParamField type="string | string[]">
  Cc recipient email address. For multiple addresses, send as an array of
  strings.
</ParamField>

<ResendParamField type="string">
  Schedule email to be sent later. The date should be in natural language (e.g.: `in 1 min`) or ISO 8601 format (e.g:
  `2024-08-05T11:52:01.858Z`).

  [See examples](/dashboard/emails/schedule-email)
</ResendParamField>

<ResendParamField type="string | string[]">
  Reply-to email address. For multiple addresses, send as an array of strings.
</ResendParamField>

<ParamField type="string">
  The HTML version of the message.
</ParamField>

<ParamField type="string">
  The plain text version of the message.

  <Info>
    If not provided, the HTML will be used to generate a plain text version. You
    can opt out of this behavior by setting value to an empty string.
  </Info>
</ParamField>

<ParamField type="React.ReactNode">
  The React component used to write the message. *Only available in the Node.js
  SDK.*
</ParamField>

<ParamField type="object">
  Custom headers to add to the email.
</ParamField>

<ResendParamField type="string">
  The topic ID to receive the email.

  * If the recipient is a contact and has opted-in to the topic, the email is sent.
  * If the recipient is a contact and has opted-out of the topic, the email is not sent and an error is returned.
  * If the recipient is not a contact, the email is sent if the topic default subscription value is set to `opt-in`.

  <Note>Each email address (to, cc, bcc) is checked and handled separately.</Note>
</ResendParamField>

<ParamField type="array">
  Filename and content of attachments (max 40MB per email, after Base64 encoding of the attachments).

  [See examples](/dashboard/emails/attachments)

  <Expandable title="properties">
    <ParamField type="buffer | string">
      Content of an attached file, passed as a buffer or Base64 string.
    </ParamField>

    <ParamField type="string">
      Name of attached file.
    </ParamField>

    <ParamField type="string">
      Path where the attachment file is hosted
    </ParamField>

    <ResendParamField type="string">
      Content type for the attachment, if not set will be derived from the filename property
    </ResendParamField>

    <ResendParamField type="string">
      You can embed images using the content id parameter for the attachment. To show the image, you need to include the ID in the `src` attribute of the `img` tag (e.g., `<img src="cid:...">`) of your HTML. [Learn about inline images](/dashboard/emails/embed-inline-images).
    </ResendParamField>
  </Expandable>
</ParamField>

<ParamField type="array">
  Custom data passed in key/value pairs.

  [See examples](/dashboard/emails/tags).

  <Expandable title="properties">
    <ParamField type="string">
      The name of the email tag.

      It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (\_), or dashes (-).

      It can contain no more than 256 characters.
    </ParamField>

    <ParamField type="string">
      The value of the email tag.

      It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (\_), or dashes (-).

      It can contain no more than 256 characters.
    </ParamField>
  </Expandable>
</ParamField>

<ParamField type="object">
  To send using a template, provide a `template` object with:

  * `id`: the id *or* the alias of the published template
  * `variables`: an object with a key for each variable (if applicable)

  <Info>
    If a `template` is provided, you cannot send `html`, `text`, or `react` in the payload, otherwise the API will return a validation error.

    When sending a template, the payload for `from`, `subject`, and `reply_to` take precedence over the template's defaults for these fields. If the template does not provide a default value for these fields, you must provide them in the payload.
  </Info>
</ParamField>

<ParamField type="string">
  The id of the published email template. Required if `template` is provided. Only published templates can be used when sending emails.
</ParamField>

<ParamField type="object">
  Template variables object with key/value pairs.

  ```ts theme={null}
  variables: {
  	CTA: 'Sign up now',
  	CTA_LINK: 'https://example.com/signup'
  }
  ```

  When sending the template, the HTML will be parsed. If all the variables used in the template were provided, the email will be sent. If not, the call will throw a validation error.

  See the [errors reference](/api-reference/errors) for more details or [learn more about templates](/dashboard/templates/introduction).

  <Expandable title="properties">
    <ParamField type="string">
      The key of the variable.

      May only contain ASCII letters (a–z, A–Z), numbers (0–9), and underscores (\_). The following variable names are reserved and cannot be used: `FIRST_NAME`, `LAST_NAME`, `EMAIL`, `UNSUBSCRIBE_URL`.

      It can contain no more than 50 characters.
    </ParamField>

    <ParamField>
      The value of the variable.

      Observe these technical limitations:

      * `string`: maximum length of 2,000 characters
      * `number`: not greater than 2^53 - 1
    </ParamField>
  </Expandable>
</ParamField>

## Headers

<ParamField type="string">
  Add an idempotency key to prevent duplicated emails.

  * Should be **unique per API request**
  * Idempotency keys expire after **24 hours**
  * Have a maximum length of **256 characters**

  [Learn more](/dashboard/emails/idempotency-keys)
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<p>it works!</p>',
    replyTo: 'onboarding@resend.dev',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'hello world',
    'html' => '<p>it works!</p>',
    'reply_to': 'onboarding@resend.dev'
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "reply_to": "onboarding@resend.dev"
  }

  email = resend.Emails.send(params)
  print(email)
  ```

  ```rb Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "reply_to": "onboarding@resend.dev"
  }

  sent = Resend::Emails.send(params)
  puts sent
  ```

  ```go Go theme={null}
  import (
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

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

    params := &resend.SendEmailRequest{
        From:        "Acme <onboarding@resend.dev>",
        To:          []string{"delivered@resend.dev"},
        Subject:     "hello world",
        Html:        "<p>it works!</p>",
        ReplyTo:     "onboarding@resend.dev"
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::types::{CreateEmailBaseOptions};
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "hello world";
    let html = "<p>it works!</p>";
    let reply_to = "onboarding@resend.dev";

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html(html);

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          CreateEmailOptions params = CreateEmailOptions.builder()
                  .from("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("hello world")
                  .html("<p>it works!</p>")
                  .replyTo("onboarding@resend.dev")
                  .build();

          CreateEmailResponse data = resend.emails().send(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.EmailSendAsync( new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
      ReplyTo = "onboarding@resend.dev",
  } );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "reply_to": "onboarding@resend.dev"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
  }
  ```
</ResponseExample>


# Update Email
Source: https://resend.com/docs/api-reference/emails/update-email

PATCH /emails/:id
Update a scheduled email.

## Path Parameters

<ParamField type="string">
  The Email ID.
</ParamField>

## Body Parameters

<ResendParamField type="string">
  Schedule email to be sent later. The date should be in ISO 8601 format (e.g:
  2024-08-05T11:52:01.858Z).
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const oneMinuteFromNow = new Date(Date.now() + 1000 * 60).toISOString();

  const { data, error } = await resend.emails.update({
    id: '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794',
    scheduledAt: oneMinuteFromNow,
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $oneMinuteFromNow = (new DateTime())->modify('+1 minute')->format(DateTime::ISO8601);

  $resend->emails->update('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794', [
    'scheduled_at' => $oneMinuteFromNow
  ]);
  ```

  ```python Python theme={null}
  import resend
  from datetime import datetime, timedelta

  resend.api_key = "re_xxxxxxxxx"

  one_minute_from_now = (datetime.now() + timedelta(minutes=1)).isoformat()

  update_params: resend.Emails.UpdateParams = {
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    "scheduled_at": one_minute_from_now
  }

  resend.Emails.update(params=update_params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  one_minute_from_now = (Time.now + 1 * 60).strftime("%Y-%m-%dT%H:%M:%S.%L%z")

  update_params = {
    "email_id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    "scheduled_at": one_minute_from_now
  }

  Resend::Emails.update(update_params)
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  oneMinuteFromNow := time.Now().Add(time.Minute * time.Duration(1))
  oneMinuteFromNowISO := oneMinuteFromNow.Format("2006-01-02T15:04:05-0700")

  updateParams := &resend.UpdateEmailRequest{
    Id:          "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    ScheduledAt: oneMinuteFromNowISO
  }

  updatedEmail, err := client.Emails.Update(updateParams)

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v\n", updatedEmail)
  ```

  ```rust Rust theme={null}
  use chrono::{Local, TimeDelta};
  use resend_rs::types::UpdateEmailOptions;
  use resend_rs::{Resend, Result};

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

    let one_minute_from_now = Local::now()
      .checked_add_signed(TimeDelta::minutes(1))
      .unwrap()
      .to_rfc3339();

    let update = UpdateEmailOptions::new()
      .with_scheduled_at(&one_minute_from_now);

    let _email = resend
      .emails
      .update("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", update)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  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();

          UpdateEmailOptions updateParams = UpdateEmailOptions.builder()
                  .scheduledAt(oneMinuteFromNow)
                  .build();

          UpdateEmailResponse data = resend.emails().update("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", updateParams);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.EmailRescheduleAsync(
      new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ),
      DateTime.UtcNow.AddMinutes( 1 ) );
  ```

  ```bash cURL theme={null}
  curl -X PATCH 'https://api.resend.com/emails/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "scheduled_at": "2024-08-05T11:52:01.858Z"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "email",
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794"
  }
  ```
</ResponseExample>


# Errors
Source: https://resend.com/docs/api-reference/errors

Troubleshoot problems with this comprehensive breakdown of all error codes.

## Error schema

We use standard HTTP response codes for success and failure notifications, and our errors are further classified by type.

### `invalid_idempotency_key`

* **Status:** 400
* **Message:** The key must be between 1-256 chars.
* **Suggested action:** Retry with a valid idempotency key.

### `validation_error`

* **Status:** 400
* **Message:** We found an error with one or more fields in the request.
* **Suggested action:** The message will contain more details about what field and error were found.

### `missing_api_key`

* **Status:** 401
* **Message:** Missing API key in the authorization header.
* **Suggested action:** Include the following header in the request: `Authorization: Bearer YOUR_API_KEY`.

### `restricted_api_key`

* **Status:** 401
* **Message:** This API key is restricted to only send emails.
* **Suggested action:** Make sure the API key has `Full access` to perform actions other than sending emails.

### `invalid_api_key`

* **Status:** 403
* **Message:** API key is invalid.
* **Suggested action:** Make sure the API key is correct or generate a new [API key in the dashboard](https://resend.com/api-keys).

### `validation_error`

* **Status:** 403
* **Message:** You can only send testing emails to your own email address (`youremail@domain.com`). To send emails to other recipients, please verify a domain at resend.com/domains, and change the `from` address to an email using this domain.
* **Suggested action:** In [Resend's Domain page](https://resend.com/domains), add and verify a domain for which you have DNS access. This allows you to send emails to addresses beyond your own. [Learn more about resolving this error](/knowledge-base/403-error-resend-dev-domain).

### `validation_error`

* **Status:** 403
* **Message:** The `domain.com` domain is not verified. Please, add and verify your domain.
* **Suggested action:** Make sure the domain in your API request's `from` field matches a domain you've verified in Resend. Update your API request to use your verified domain, or add and verify the domain you're trying to use. [Learn more about resolving this error](/knowledge-base/403-error-domain-mismatch).

### `not_found`

* **Status:** 404
* **Message:** The requested endpoint does not exist.
* **Suggested action:** Change your request URL to match a valid API endpoint.

### `method_not_allowed`

* **Status:** 405
* **Message:** Method is not allowed for the requested path.
* **Suggested action:** Change your API endpoint to use a valid method.

### `invalid_idempotent_request`

* **Status:** 409
* **Message:** Same idempotency key used with a different request payload.
* **Suggested action:** Change your idempotency key or payload.

### `concurrent_idempotent_requests`

* **Status:** 409
* **Message:** Same idempotency key used while original request is still in progress.
* **Suggested action:** Try the request again later.

### `invalid_attachment`

* **Status:** 422
* **Message:** Attachment must have either a `content` or `path`.
* **Suggested action:** Attachments must either have a `content` (strings, Buffer, or Stream contents) or `path` to a remote resource (better for larger attachments).

### `invalid_from_address`

* **Status:** 422
* **Message:** Invalid `from` field.
* **Suggested action:** Make sure the `from` field is a valid. The email address needs to follow the `email@example.com` or `Name <email@example.com>` format.

### `invalid_access`

* **Status:** 422
* **Message:** Access must be "full\_access" | "sending\_access".
* **Suggested action:** Make sure the API key has necessary permissions.

### `invalid_parameter`

* **Status:** 422
* **Message:** The `parameter` must be a valid UUID.
* **Suggested action:** Check the value and make sure it's valid.

### `invalid_region`

* **Status:** 422
* **Message:** Region must be "us-east-1" | "eu-west-1" | "sa-east-1".
* **Suggested action:** Make sure the correct region is selected.

### `missing_required_field`

* **Status:** 422
* **Message:** The request body is missing one or more required fields.
* **Suggested action:** Check the error message to see the list of missing fields.

### `monthly_quota_exceeded`

* **Status:** 429
* **Message:** You have reached your monthly email quota.
* **Suggested action:** [Upgrade your plan](https://resend.com/settings/billing) to increase the monthly email quota. Both sent and received emails count towards this quota.

### `daily_quota_exceeded`

* **Status:** 429
* **Message:** You have reached your daily email quota.
* **Suggested action:** [Upgrade your plan](https://resend.com/settings/billing) to remove the daily quota limit or wait until 24 hours have passed. Both sent and received emails count towards this quota.

### `rate_limit_exceeded`

* **Status:** 429
* **Message:** Too many requests. Please limit the number of requests per second. Or [contact support](https://resend.com/contact) to increase rate limit.
* **Suggested action:** You should read the [response headers](./introduction#rate-limit) and reduce the rate at which you request the API. This can be done by introducing a queue mechanism or reducing the number of concurrent requests per second. If you have specific requirements, [contact support](https://resend.com/contact) to request a rate increase.

### `security_error`

* **Status:** 451
* **Message:** We may have found a security issue with the request.
* **Suggested action:** The message will contain more details. [Contact support](https://resend.com/contact) for more information.

### `application_error`

* **Status:** 500
* **Message:** An unexpected error occurred.
* **Suggested action:** Try the request again later. If the error does not resolve, check our [status page](https://resend-status.com) for service updates.

### `internal_server_error`

* **Status:** 500
* **Message:** An unexpected error occurred.
* **Suggested action:** Try the request again later. If the error does not resolve, check our [status page](https://resend-status.com) for service updates.


# Introduction
Source: https://resend.com/docs/api-reference/introduction

Understand general concepts, response codes, and authentication strategies.

## Base URL

The Resend API is built on **REST** principles. We enforce **HTTPS** in every request to improve data security, integrity, and privacy. The API does not support **HTTP**.

All requests contain the following base URL:

```
https://api.resend.com
```

## Authentication

To authenticate you need to add an *Authorization* header with the contents of the header being `Bearer re_xxxxxxxxx` where `re_xxxxxxxxx` is your [API Key](https://resend.com/api-keys).

```
Authorization: Bearer re_xxxxxxxxx
```

## Response codes

Resend uses standard HTTP codes to indicate the success or failure of your requests.

In general, `2xx` HTTP codes correspond to success, `4xx` codes are for user-related failures, and `5xx` codes are for infrastructure issues.

| Status | Description                             |
| ------ | --------------------------------------- |
| `200`  | Successful request.                     |
| `400`  | Check that the parameters were correct. |
| `401`  | The API key used was missing.           |
| `403`  | The API key used was invalid.           |
| `404`  | The resource was not found.             |
| `429`  | The rate limit was exceeded.            |
| `5xx`  | Indicates an error with Resend servers. |

<Info>
  Check [Error Codes](/api-reference/errors) for a comprehensive breakdown of
  all possible API errors.
</Info>

## Rate limit

The default maximum rate limit is **2 requests per second**. This number can be increased for trusted senders by request. After that, you'll hit the rate limit and receive a `429` response error code.

Learn more about our [rate limits](/api-reference/rate-limit).

## FAQ

<AccordionGroup>
  <Accordion title="How does pagination work with the API?">
    Some endpoints support cursor-based pagination to help you browse through
    large datasets efficiently. Check our [pagination
    guide](/api-reference/pagination) for detailed information on how to use
    pagination parameters.
  </Accordion>

  <Accordion title="How do you handle API versioning?">
    Currently, there's no versioning system in place. We plan to add versioning
    via calendar-based headers in the future.
  </Accordion>
</AccordionGroup>


# Pagination
Source: https://resend.com/docs/api-reference/pagination

Learn how pagination works in the Resend API.

## Overview

Several Resend API endpoints support **cursor-based pagination** to help you efficiently browse through large datasets. You can safely navigate lists with guaranteed stability, even if new objects are created or deleted while you're still requesting pages.

Paginated endpoints responses include:

* `object`: always set to `list`.
* `has_more`: indicates whether there are more elements available.
* `data`: the list of returned items.

You can navigate through the results using the following parameters:

* `limit`: the number of items to return per page.
* `after`: the cursor to use to get the next page of results.
* `before`: the cursor to use to get the previous page of results.

Use the `id` of objects as the cursor for pagination. The cursor itself is *excluded* from the results. For an example, see [pagination strategies below](#strategies).

## Currently-supported endpoints

Existing list endpoints can optionally return paginated results:

* [List Domains](/api-reference/domains/list-domains)
* [List API Keys](/api-reference/api-keys/list-api-keys)
* [List Broadcasts](/api-reference/broadcasts/list-broadcasts)
* [List Segments](/api-reference/segments/list-segments)
* [List Contacts](/api-reference/contacts/list-contacts)
* [List Receiving Emails](/api-reference/emails/list-received-emails)
* [List Receiving Email Attachments](/api-reference/emails/list-received-email-attachments)

<Info>
  Note that for these endpoints, the `limit` parameter is optional. If you do
  not provide a `limit`, all items will be returned in a single response.
</Info>

Newer list endpoints always return paginated results:

* [List Emails](/api-reference/emails/list-emails)
* [List Templates](/api-reference/templates/list-templates)
* [List Topics](/api-reference/topics/list-topics)

## Parameters

All paginated endpoints support the following query parameters:

<ParamField type="number">
  The number of items to return per page. Default is `20`, maximum is `100`, and
  minimum is `1`.
</ParamField>

<ParamField type="string">
  The cursor after which to start retrieving items. To get the next page, use
  the ID of the last item from the current page. This will return the page that
  **starts after** the object with this ID (excluding the passed ID itself).
</ParamField>

<ParamField type="string">
  The cursor before which to start retrieving items. To get the previous page,
  use the ID of the first item from the current page. This will return the page
  that **ends before** the object with this ID (excluding the passed ID itself).
</ParamField>

<Warning>
  You can only use either `after` or `before`, not both simultaneously.
</Warning>

## Response Format

Paginated endpoints return responses in the following format:

```json Response Format theme={null}
{
  "object": "list",
  "has_more": true,
  "data": [
    /* Array of resources */
  ]
}
```

<ResponseField name="object" type="string">
  Always set to `list` for paginated responses.
</ResponseField>

<ResponseField name="has_more" type="boolean">
  Indicates whether there are more items available beyond the current page.
</ResponseField>

<ResponseField name="data" type="array">
  An array containing the actual resources for the current page.
</ResponseField>

## Strategies

### Forward Pagination

To paginate forward through results (newer to older items), use the `after` parameter with the ID of the **last item** from the current page:

<CodeGroup>
  ```ts Node.js theme={null}
  const resend = new Resend('re_xxxxxxxxx');

  // First page
  const { data: firstPage } = await resend.contacts.list({ limit: 50 });

  // Second page (if has_more is true)
  if (firstPage.has_more) {
    const lastId = firstPage.data[firstPage.data.length - 1].id;
    const { data: secondPage } = await resend.contacts.list({
      limit: 50,
      after: lastId,
    });
  }
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // First page
  $firstPage = $resend->contacts->list(['limit' => 50]);

  // Second page (if has_more is true)
  if ($firstPage['has_more']) {
      $lastId = end($firstPage['data'])['id'];
      $secondPage = $resend->contacts->list([
          'limit' => 50,
          'after' => $lastId
      ]);
  }
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  # First page
  first_page = resend.Contacts.list(limit=50)

  # Second page (if has_more is true)
  if first_page['has_more']:
      last_id = first_page['data'][-1]['id']
      second_page = resend.Contacts.list(limit=50, after=last_id)
  ```

  ```ruby Ruby theme={null}
  Resend.api_key = "re_xxxxxxxxx"

  # First page
  first_page = Resend::Contacts.list(limit: 50)

  # Second page (if has_more is true)
  if first_page['has_more']
    last_id = first_page['data'].last['id']
    second_page = Resend::Contacts.list(limit: 50, after: last_id)
  end
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  // First page
  firstPage, err := client.Contacts.List(&resend.ListContactsRequest{
      Limit: 50,
  })

  // Second page (if has_more is true)
  if firstPage.HasMore {
      lastId := firstPage.Data[len(firstPage.Data)-1].ID
      secondPage, err := client.Contacts.List(&resend.ListContactsRequest{
          Limit: 50,
          After: lastId,
      })
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result, types::ListContactOptions};

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

      // First page
      let list_opts = ListContactOptions::default().with_limit(50);
      let first_page = resend.emails.list(list_opts).await?;

      // Second page (if has_more is true)
      if first_page.has_more {
          let last_id = &first_page.data.last().unwrap().id;
          let list_opts = ListContactOptions::default()
              .with_limit(10)
              .list_after(last_id);
          let second_page = resend.contacts.list(list_opts).await?;
      }

      Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          // First page
          ListEmailsResponse firstPage = resend.emails().list(10);

          // Second page (if has_more is true)
          if (firstPage.getHasMore()) {
              String lastId = firstPage.getData().get(firstPage.getData().size() - 1).getId();
              ListContactsResponse secondPage = resend.contacts().list(50, lastId, null);
          }
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;
  using System.Linq;

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

  // First page
  var firstPage = await resend.EmailListAsync( new PaginatedQuery() {
    Limit = 50,
  });

  // Second page (if has_more is true)
  if (firstPage.Content.HasMore)
  {
      var lastId = firstPage.Content.Data.Last().Id;
      var secondPage = await resend.EmailListAsync( new PaginatedQuery() {
        Limit = 50,
        After = lastId.ToString(),
      });
  }
  ```

  ```bash cURL theme={null}
  # First page
  curl -X GET 'https://api.resend.com/contacts?limit=50' \
       -H 'Authorization: Bearer re_xxxxxxxxx'

  # Second page
  curl -X GET 'https://api.resend.com/contacts?limit=50&after=LAST_ID_FROM_PREVIOUS_PAGE' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</CodeGroup>

### Backward Pagination

To paginate backward through results (older to newer items), use the `before` parameter with the ID of the **first item** from the current page (or the most recent ID you have in your system):

<CodeGroup>
  ```ts Node.js theme={null}
  const resend = new Resend('re_xxxxxxxxx');

  // Start from a specific point and go backward
  const page = await resend.contacts.list({
    limit: 50,
    before: 'some-contact-id',
  });

  if (page.data.has_more) {
    const firstId = page.data.data[0].id;
    const previousPage = await resend.contacts.list({
      limit: 50,
      before: firstId,
    });
  }
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Start from a specific point and go backward
  $page = $resend->contacts->list([
      'limit' => 50,
      'before' => 'some-contact-id'
  ]);

  if ($page['has_more']) {
      $firstId = $page['data'][0]['id'];
      $previousPage = $resend->contacts->list([
          'limit' => 50,
          'before' => $firstId
      ]);
  }
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  # Start from a specific point and go backward
  page = resend.Contacts.list(limit=50, before="some-contact-id")

  if page["has_more"]:
      first_id = page["data"][0]["id"]
      previous_page = resend.Contacts.list(limit=50, before=first_id)
  ```

  ```ruby Ruby theme={null}
  Resend.api_key = "re_xxxxxxxxx"

  # Start from a specific point and go backward
  page = Resend::Contacts.list(limit: 50, before: 'some-contact-id')

  if page['has_more']
    first_id = page['data'].first['id']
    previous_page = Resend::Contacts.list(limit: 50, before: first_id)
  end
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  // Start from a specific point and go backward
  page, err := client.Contacts.List(&resend.ListContactsRequest{
      Limit:  resend.Int(50),
      Before: resend.String("some-contact-id"),
  })

  if page.HasMore {
      firstId := page.Data[0].ID
      previousPage, err := client.Contacts.List(&resend.ListContactsRequest{
          Limit:  resend.Int(50),
          Before: resend.String(firstId),
      })
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result, types::ListContactOptions};

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

      // Start from a specific point and go backward
      let list_opts = ListContactOptions::default()
          .with_limit(50)
          .list_before("some-email-id");
      let page = resend.contacts.list(list_opts).await?;

      if page.has_more {
          let first_id = &page.data.first().unwrap().id;
          let list_opts = ListContactOptions::default()
              .with_limit(10)
              .list_before(first_id);
          let previous_page = resend.contacts.list(list_opts).await?;
      }

      Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          // Start from a specific point and go backward
          ListContactsResponse page = resend.contacts().list(50, null, "some-contact-id");

          if (page.getHasMore()) {
              String firstId = page.getData().get(0).getId();
              ListContactsResponse previousPage = resend.contacts().list(50, null, firstId);
          }
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;
  using System.Linq;

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

  // Start from a specific point and go backward
  var page = await resend.EmailListAsync( new PaginatedQuery() {
    Limit = 50,
    Before = "some-email-id",
  });

  if (page.Content.HasMore)
  {
      var firstId = page.Content.Data.First().Id;
      var prevPage = await resend.EmailListAsync( new PaginatedQuery() {
        Limit = 50,
        Before = firstId.ToString(),
      });
  }
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/contacts?limit=50&before=some-contact-id' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</CodeGroup>

## Best Practices

<AccordionGroup>
  <Accordion title="Use appropriate page sizes">
    Choose a `limit` that balances performance and usability. Smaller pages are good for real-time applications, while larger pages
    (hundreds of items) work better for bulk processing.
  </Accordion>

  <Accordion title="Handle pagination gracefully">
    Always check the `has_more` field before attempting to fetch additional pages.
    This prevents unnecessary API calls when you've reached the end of the
    dataset.
  </Accordion>

  <Accordion title="Consider rate limits">
    Be mindful of API rate limits when paginating through large datasets.
    Implement appropriate delays or batching strategies if processing many
    pages.
  </Accordion>
</AccordionGroup>

## Error Handling

Pagination requests may return the following validation errors:

| Error              | Description                                         |
| ------------------ | --------------------------------------------------- |
| `validation_error` | Invalid cursor format or limit out of range (1-100) |
| `validation_error` | Both `before` and `after` parameters provided       |

Example error response:

```json Error Response theme={null}
{
  "name": "validation_error",
  "statusCode": 422,
  "message": "The pagination limit must be a number between 1 and 100. See https://resend.com/docs/pagination for more information."
}
```


# Usage Limits
Source: https://resend.com/docs/api-reference/rate-limit

Learn about API rate limits, email sending quotas, and contact quotas.

The Resend API enforces three types of limits: **rate limits** control how many API requests you can make per second, **email quotas** control the total number of emails you can send per day and month, and **contact quotas** control how many marketing contacts you can store.

## Rate Limits

### Response Headers

The response headers describe your current rate limit following every request in conformance with the [sixth IETF standard draft](https://datatracker.ietf.org/doc/html/draft-ietf-httpapi-ratelimit-headers-06):

| Header name           | Description                                                         |
| --------------------- | ------------------------------------------------------------------- |
| `ratelimit-limit`     | Maximum number of requests allowed within a window.                 |
| `ratelimit-remaining` | How many requests you have left within the current window.          |
| `ratelimit-reset`     | How many seconds until the limits are reset.                        |
| `retry-after`         | How many seconds you should wait before making a follow-up request. |

The default maximum rate limit is **2 requests per second**. This number can be increased for trusted senders upon request.

After that, you'll hit the rate limit and receive a `429` response error code. You can find all 429 responses by filtering for 429 at the [Resend Logs page](https://resend.com/logs?status=429).

To prevent this, we recommend reducing the rate at which you request the API. This can be done by introducing a queue mechanism or reducing the number of concurrent requests per second. If you have specific requirements, [contact support](https://resend.com/contact) to request a rate increase.

## Email Quotas

### Response Headers

In addition to rate limits, the API returns headers that track your email sending quotas:

| Header name              | Description                                                             |
| ------------------------ | ----------------------------------------------------------------------- |
| `x-resend-daily-quota`   | Your remaining daily email sending quota. Only sent to free plan users. |
| `x-resend-monthly-quota` | Your remaining monthly email sending quota.                             |

These headers help you monitor your usage and avoid hitting quota limits.

When you exceed your quota limits, you'll receive a `429` response error code with one of the following error types:

* **`daily_quota_exceeded`** - You have reached your daily email quota. [Upgrade your plan](https://resend.com/settings/billing) to remove the daily quota limit or wait until 24 hours have passed.
* **`monthly_quota_exceeded`** - You have reached your monthly email quota. [Upgrade your plan](https://resend.com/settings/billing) to increase the monthly email quota.

Both sent and received emails count towards these quotas. See the full list of [error codes](/api-reference/errors) for more details.

## Contact Quotas

Contact quotas restrict the number of contacts you can store for marketing emails and broadcasts. You can add more contacts beyond your plan's limit, but you won't be able to send broadcasts until you upgrade your plan.

When you attempt to send a broadcast after reaching your contact limit, you'll receive a `403` response error code with a `validation_error` type and the message: "You have reached your contacts quota. Please upgrade your plan to send more emails."

To increase your contact limit, [upgrade your Marketing plan](https://resend.com/settings/billing).


# Create Segment
Source: https://resend.com/docs/api-reference/segments/create-segment

POST /segments
Create a new segment for contacts to be added to.

## Body Parameters

<ParamField type="string">
  The name of the segment you want to create.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.segments.create({
    name: 'Registered Users',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->segments->create([
    'name' => 'Registered Users',
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  params = {
      "name": "Registered Users",
  }

  segment = resend.Segments.create(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    name: "Registered Users",
  }
  segment = Resend::Segments.create(params)
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	params := &resend.CreateSegmentRequest{
  		Name: "Registered Users",
  	}

  	segment, err := client.Segments.CreateWithContext(ctx, params)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(segment)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _segment = resend.segments.create("Registered Users").await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          CreateSegmentOptions options = CreateSegmentOptions.builder()
              .name("Registered Users")
              .build();

          CreateSegmentResponseSuccess response = resend.segments().create(options);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.SegmentCreateAsync( new SegmentData() {
    Name = "Registered Users",
  } );
  Console.WriteLine( "Segment Id={0}", resp.Content );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/segments' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "Registered Users"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "segment",
    "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    "name": "Registered Users"
  }
  ```
</ResponseExample>


# Delete Segment
Source: https://resend.com/docs/api-reference/segments/delete-segment

DELETE /segments/:segment_id
Remove an existing segment.

## Path Parameters

<ResendParamField type="string">
  The Segment ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.segments.remove(
    '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->segments->remove('78261eea-8f8b-4381-83c6-79fa7120f1cf');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  segment = resend.Segments.remove(id='78261eea-8f8b-4381-83c6-79fa7120f1cf')
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Segments.remove("78261eea-8f8b-4381-83c6-79fa7120f1cf")
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	segment, err := client.Segments.RemoveWithContext(ctx, "78261eea-8f8b-4381-83c6-79fa7120f1cf")
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(segment)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _segment = resend
      .segments
      .delete("78261eea-8f8b-4381-83c6-79fa7120f1cf")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          RemoveSegmentResponseSuccess response = resend.segments().remove("78261eea-8f8b-4381-83c6-79fa7120f1cf");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X DELETE 'https://api.resend.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "segment",
    "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    "deleted": true
  }
  ```
</ResponseExample>


# Retrieve Segment
Source: https://resend.com/docs/api-reference/segments/get-segment

GET /segments/:segment_id
Retrieve a single segment.

## Path Parameters

<ResendParamField type="string">
  The Segment ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.segments.get(
    '78261eea-8f8b-4381-83c6-79fa7120f1cf',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->segments->get('78261eea-8f8b-4381-83c6-79fa7120f1cf');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  segment = resend.Segments.get('78261eea-8f8b-4381-83c6-79fa7120f1cf')
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  segment = Resend::Segments.get("78261eea-8f8b-4381-83c6-79fa7120f1cf")
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	segment, err := client.Segments.GetWithContext(ctx, "78261eea-8f8b-4381-83c6-79fa7120f1cf")
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(segment)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _segment = resend
      .segments
      .get("78261eea-8f8b-4381-83c6-79fa7120f1cf")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          GetSegmentResponseSuccess response = resend.segments().get("78261eea-8f8b-4381-83c6-79fa7120f1cf");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.SegmentRetrieveAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
  Console.WriteLine( "Segment Id={0}", resp.Content.Id );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/segments/78261eea-8f8b-4381-83c6-79fa7120f1cf' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "segment",
    "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    "name": "Registered Users",
    "created_at": "2023-10-06T22:59:55.977Z"
  }
  ```
</ResponseExample>


# List Segments
Source: https://resend.com/docs/api-reference/segments/list-segments

GET /segments
Retrieve a list of segments.

<QueryParams type="segments" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  segments = resend.Segments.list()
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  segments = Resend::Segments.list
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	segments, err := client.Segments.ListWithContext(ctx)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(segments)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let _segments = resend.segments.list(ListOptions::default()).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          ListSegmentsResponseSuccess response = resend.segments().list();
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/segments' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
        "name": "Registered Users",
        "created_at": "2023-10-06T22:59:55.977Z"
      }
    ]
  }
  ```
</ResponseExample>


# Create Template
Source: https://resend.com/docs/api-reference/templates/create-template

POST /templates
Create a new template with optional variables.

## Body Parameters

<ParamField type="string">
  The name of the template.
</ParamField>

<ParamField type="string">
  The HTML version of the template.
</ParamField>

<ParamField type="string">
  The alias of the template.
</ParamField>

<ParamField type="string">
  Sender email address.

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

  If provided, this value can be overridden when sending an email using the template.
</ParamField>

<ParamField type="string">
  Default email subject.

  This value can be overridden when sending an email using the template.
</ParamField>

<ResendParamField type="string | string[]">
  Default Reply-to email address. For multiple addresses, send as an array of strings.

  This value can be overridden when sending an email using the template.
</ResendParamField>

<ParamField type="string">
  The plain text version of the message.

  <Info>
    If not provided, the HTML will be used to generate a plain text version. You can opt out of this behavior by setting value to an empty string.
  </Info>
</ParamField>

<ParamField type="React.ReactNode">
  The React component used to write the template. *Only available in the Node.js
  SDK.*
</ParamField>

<ParamField type="array">
  The array of variables used in the template. Each template may contain up to 50 variables.

  Each variable is an object with the following properties:

  <Expandable title="properties">
    <ParamField type="string">
      The key of the variable. We recommend capitalizing the key (e.g. `PRODUCT_NAME`). The following variable names are reserved and cannot be used:
      `FIRST_NAME`, `LAST_NAME`, `EMAIL`, `RESEND_UNSUBSCRIBE_URL`, `contact`, and `this`.
    </ParamField>

    <ParamField type="'string' | 'number'">
      The type of the variable.

      Can be `'string'` or `'number'`
    </ParamField>

    <ResendParamField>
      The fallback value of the variable. The value must match the type of the variable.

      If no fallback value is provided, you must provide a value for the variable when sending an email using the template.
    </ResendParamField>
  </Expandable>

  <Info>
    Before you can use a template, you must publish it first. To publish a
    template, use the [Templates dashboard](https://resend.com/templates) or
    [publish template API](/api-reference/templates/publish-template).

    [Learn more about Templates](/dashboard/templates/introduction).
  </Info>
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.templates.create({
    name: 'order-confirmation',
    html: '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
    variables: [
      {
        key: 'PRODUCT',
        type: 'string',
        fallbackValue: 'item',
      },
      {
        key: 'PRICE',
        type: 'number',
        fallbackValue: 25,
      }
    ],
  });

  // Or create and publish a template in one step
  await resend.templates.create({ ... }).publish();
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->templates->create([
    'name' => 'order-confirmation',
    'html' => '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
    'variables' => [
      [
        'key' => 'PRODUCT',
        'type' => 'string',
        'fallback_value' => 'item',
      ],
      [
        'key' => 'PRICE',
        'type' => 'number',
        'fallback_value' => 25,
      ]
    ],
  ]);
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Templates.create({
      "name": "order-confirmation",
      "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
      "variables": [
          {
              "key": "PRODUCT",
              "type": "string",
              "fallback_value": "item",
          },
          {
              "key": "PRICE",
              "type": "number",
              "fallback_value": 25,
          }
      ],
  })
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Templates.create(
    name: "order-confirmation",
    html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    variables: [
      {
        key: "PRODUCT",
        type: "string",
        fallback_value: "item"
      },
      {
        key: "PRICE",
        type: "number",
        fallback_value: 25
      }
    ]
  )
  ```

  ```go Go theme={null}
  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: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  		Variables: []*resend.TemplateVariable{
  			{
  				Key:           "PRODUCT",
  				Type:          resend.VariableTypeString,
  				FallbackValue: "item",
  			},
  			{
  				Key:           "PRICE",
  				Type:          resend.VariableTypeNumber,
  				FallbackValue: 25,
  			}
  		},
  	})
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    types::{CreateTemplateOptions, Variable, VariableType},
    Resend, Result,
  };

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

    let name = "order-confirmation";
    let html = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>";

    let variables = [
      Variable::new("PRODUCT", VariableType::String).with_fallback("item"),
      Variable::new("PRICE", VariableType::Number).with_fallback(25)
    ];

    let opts = CreateTemplateOptions::new(name, html).with_variables(&variables);
    let template = resend.templates.create(opts).await?;

    let _published = resend.templates.publish(&template.id).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  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("<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>")
                  .addVariable(new Variable("PRODUCT", VariableType.STRING, "item"))
                  .addVariable(new Variable("PRICE", VariableType.NUMBER, 25))
                  .build();

          CreateTemplateResponseSuccess data = resend.templates().create(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var variables = new List<TemplateVariable>()
  {
    new TemplateVariable() {
      Key = "PRODUCT",
      Type = TemplateVariableType.String,
      Default = "item",
    },
    new TemplateVariable() {
      Key = "PRICE",
      Type = TemplateVariableType.Number,
      Default = 25,
    }
  };

  var resp = await resend.TemplateCreateAsync(
    new TemplateData()
    {
      Name = "welcome-email",
      HtmlBody = "<strong>Hey, {{{PRODUCT}}}, you are {{{PRICE}}} years old.</strong>",
      Variables = variables,
    }
  );

  Console.WriteLine($"Template Id={resp.Content}");
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/templates' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "order-confirmation",
    "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    "variables": [
      {
        "key": "PRODUCT",
        "type": "string",
        "fallback_value": "item"
      },
      {
        "key": "PRICE",
        "type": "number",
        "fallback_value": 25
      }
    ]
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    "object": "template"
  }
  ```
</ResponseExample>


# Delete Template
Source: https://resend.com/docs/api-reference/templates/delete-template

DELETE /templates/:id
Delete a template.

## Path Parameters

<ParamField type="string">
  The ID or alias of the template to delete.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.templates.remove(
    '34a080c9-b17d-4187-ad80-5af20266e535',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->templates->remove('34a080c9-b17d-4187-ad80-5af20266e535');
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Templates.remove("34a080c9-b17d-4187-ad80-5af20266e535")
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Templates.remove("34a080c9-b17d-4187-ad80-5af20266e535")
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	template, err := client.Templates.RemoveWithContext(
  		context.TODO(),
  		"34a080c9-b17d-4187-ad80-5af20266e535",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _deleted = resend
      .templates
      .delete("34a080c9-b17d-4187-ad80-5af20266e535")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          DeleteTemplateResponseSuccess data = resend.templates().remove("34a080c9-b17d-4187-ad80-5af20266e535");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.TemplateDeleteAsync( new Guid( "34a080c9-b17d-4187-ad80-5af20266e535" ) );
  ```

  ```bash cURL theme={null}
  curl -X DELETE 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "template",
    "id": "34a080c9-b17d-4187-ad80-5af20266e535",
    "deleted": true
  }
  ```
</ResponseExample>


# Duplicate Template
Source: https://resend.com/docs/api-reference/templates/duplicate-template

POST /templates/:id/duplicate
Duplicate a template.

## Path Parameters

<ParamField type="string">
  The ID or alias of the template to duplicate.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.templates.duplicate(
    '34a080c9-b17d-4187-ad80-5af20266e535',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->templates->duplicate('34a080c9-b17d-4187-ad80-5af20266e535');
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Templates.duplicate("34a080c9-b17d-4187-ad80-5af20266e535")
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Templates.duplicate("34a080c9-b17d-4187-ad80-5af20266e535")
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	template, err := client.Templates.DuplicateWithContext(
  		context.TODO(),
  		"34a080c9-b17d-4187-ad80-5af20266e535",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _duplicated = resend
      .templates
      .duplicate("34a080c9-b17d-4187-ad80-5af20266e535")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          DuplicateTemplateResponseSuccess data = resend.templates().duplicate("34a080c9-b17d-4187-ad80-5af20266e535");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.TemplateDuplicateAsync( new Guid( "34a080c9-b17d-4187-ad80-5af20266e535" ) );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535/duplicate' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "template",
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3"
  }
  ```
</ResponseExample>


# Get Template
Source: https://resend.com/docs/api-reference/templates/get-template

GET /templates/:id
Get a template by ID.

## Path Parameters

<ParamField type="string">
  The ID or alias of the template to get.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.templates.get(
    '34a080c9-b17d-4187-ad80-5af20266e535',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->templates->get('34a080c9-b17d-4187-ad80-5af20266e535');
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Templates.get("34a080c9-b17d-4187-ad80-5af20266e535")
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Templates.get("34a080c9-b17d-4187-ad80-5af20266e535")
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	template, err := client.Templates.GetWithContext(
  		context.TODO(),
  		"34a080c9-b17d-4187-ad80-5af20266e535",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _template = resend
      .templates
      .get("34a080c9-b17d-4187-ad80-5af20266e535")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          GetTemplateResponseSuccess data = resend.templates().get("34a080c9-b17d-4187-ad80-5af20266e535");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var res = await resend.TemplateRetrieveAsync( new Guid( "34a080c9-b17d-4187-ad80-5af20266e535" ) );
  Console.WriteLine( "Template Name={0}", res.Content.Name );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "template",
    "id": "34a080c9-b17d-4187-ad80-5af20266e535",
    "current_version_id": "b2693018-7abb-4b4b-b4cb-aadf72dc06bd",
    "alias": "reset-password",
    "name": "reset-password",
    "created_at": "2023-10-06T23:47:56.678Z",
    "updated_at": "2023-10-06T23:47:56.678Z",
    "status": "published",
    "published_at": "2023-10-06T23:47:56.678Z",
    "from": "John Doe <john.doe@example.com>",
    "subject": "Hello, world!",
    "reply_to": null,
    "html": "<h1>Hello, world!</h1>",
    "text": "Hello, world!",
    "variables": [
      {
        "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
        "key": "user_name",
        "type": "string",
        "fallback_value": "John Doe",
        "created_at": "2023-10-06T23:47:56.678Z",
        "updated_at": "2023-10-06T23:47:56.678Z"
      }
    ],
    "has_unpublished_versions": true
  }
  ```
</ResponseExample>


# List Templates
Source: https://resend.com/docs/api-reference/templates/list-templates

GET /templates
List all templates.

By default, the API will return the most recent 20 templates. You can optionally use the `limit` parameter to return a different number of templates or control the pagination of the results with the `after` or `before` parameters.

<QueryParams type="templates" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.templates.list({
    limit: 2,
    after: '34a080c9-b17d-4187-ad80-5af20266e535',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->templates->list([
    'limit' => 2,
    'after' => '34a080c9-b17d-4187-ad80-5af20266e535'
  ]);
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Templates.list({
      "limit": 2,
      "after": "34a080c9-b17d-4187-ad80-5af20266e535",
  })
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Templates.list(
    limit: 2,
    after: "34a080c9-b17d-4187-ad80-5af20266e535"
  )
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	templates, err := client.Templates.ListWithContext(context.TODO(), &resend.ListOptions{
  		Limit: 2,
  		After: "34a080c9-b17d-4187-ad80-5af20266e535",
  	})
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let list_opts = ListOptions::default()
      .with_limit(2)
      .list_after("34a080c9-b17d-4187-ad80-5af20266e535");

    let _list = resend.templates.list(list_opts).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          ListParams params = ListParams.builder()
              .limit(2)
              .after("34a080c9-b17d-4187-ad80-5af20266e535")
              .build();

          ListTemplatesResponseSuccess data = resend.templates().list(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/templates?limit=2&after=34a080c9-b17d-4187-ad80-5af20266e535' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "data": [
      {
        "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
        "name": "reset-password",
        "status": "draft",
        "published_at": null,
        "created_at": "2023-10-06T23:47:56.678Z",
        "updated_at": "2023-10-06T23:47:56.678Z",
        "alias": "reset-password"
      },
      {
        "id": "b7f9c2e1-1234-4abc-9def-567890abcdef",
        "name": "welcome-message",
        "status": "published",
        "published_at": "2023-10-06T23:47:56.678Z",
        "created_at": "2023-10-06T23:47:56.678Z",
        "updated_at": "2023-10-06T23:47:56.678Z",
        "alias": "welcome-message"
      }
    ],
    "has_more": false
  }
  ```
</ResponseExample>


# Publish Template
Source: https://resend.com/docs/api-reference/templates/publish-template

POST /templates/:id/publish
Publish a template.

## Path Parameters

<ParamField type="string">
  The ID or alias of the template to publish.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.templates.publish(
    '34a080c9-b17d-4187-ad80-5af20266e535',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->templates->publish('34a080c9-b17d-4187-ad80-5af20266e535');
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Templates.publish("34a080c9-b17d-4187-ad80-5af20266e535")
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Templates.publish("34a080c9-b17d-4187-ad80-5af20266e535")
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	template, err := client.Templates.PublishWithContext(
  		context.TODO(),
  		"34a080c9-b17d-4187-ad80-5af20266e535",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _published = resend
      .templates
      .publish("34a080c9-b17d-4187-ad80-5af20266e535")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          PublishTemplateResponseSuccess data = resend.templates().publish("34a080c9-b17d-4187-ad80-5af20266e535");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.TemplatePublishAsync( new Guid( "34a080c9-b17d-4187-ad80-5af20266e535" ) );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535/publish' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "34a080c9-b17d-4187-ad80-5af20266e535",
    "object": "template"
  }
  ```
</ResponseExample>


# Update Template
Source: https://resend.com/docs/api-reference/templates/update-template

PATCH /templates/:id
Update a template.

## Path Parameters

<ParamField type="string">
  The ID or alias of the template to duplicate.
</ParamField>

## Body Parameters

<ParamField type="string">
  The name of the template.
</ParamField>

<ParamField type="string">
  The HTML version of the template.
</ParamField>

<ParamField type="string">
  The alias of the template.
</ParamField>

<ParamField type="string">
  Sender email address.

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

  If provided, this value can be overridden when sending an email using the template.
</ParamField>

<ParamField type="string">
  Default email subject.

  This value can be overridden when sending an email using the template.
</ParamField>

<ResendParamField type="string | string[]">
  Default Reply-to email address. For multiple addresses, send as an array of strings.

  This value can be overridden when sending an email using the template.
</ResendParamField>

<ParamField type="string">
  The plain text version of the message.

  <Info>
    If not provided, the HTML will be used to generate a plain text version. You can opt out of this behavior by setting value to an empty string.
  </Info>
</ParamField>

<ParamField type="React.ReactNode">
  The React component used to write the template. *Only available in the Node.js
  SDK.*
</ParamField>

<ParamField type="array">
  The array of variables used in the template. Each template may contain up to 50 variables.

  Each variable is an object with the following properties:

  <Expandable title="properties">
    <ParamField type="string">
      The key of the variable. We recommend capitalizing the key (e.g. `PRODUCT_NAME`). The following variable names are reserved and cannot be used:
      `FIRST_NAME`, `LAST_NAME`, `EMAIL`, `RESEND_UNSUBSCRIBE_URL`, `contact`, and `this`.
    </ParamField>

    <ParamField type="'string' | 'number'">
      The type of the variable.

      Can be `'string'` or `'number'`
    </ParamField>

    <ResendParamField>
      The fallback value of the variable. The value must match the type of the variable.

      If no fallback value is provided, you must provide a value for the variable when sending an email using the template.
    </ResendParamField>
  </Expandable>

  <Info>
    Before you can use a template, you must publish it first. To publish a
    template, use the [Templates dashboard](https://resend.com/templates) or
    [publish template API](/api-reference/templates/publish-template).

    [Learn more about Templates](/dashboard/templates/introduction).
  </Info>
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.templates.update(
    '34a080c9-b17d-4187-ad80-5af20266e535',
    {
      name: 'order-confirmation',
      html: '<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>',
    },
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->templates->update('34a080c9-b17d-4187-ad80-5af20266e535', [
    'name' => 'order-confirmation',
    'html' => '<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>',
  ]);
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Templates.update({
      "id": "34a080c9-b17d-4187-ad80-5af20266e535",
      "name": "order-confirmation",
      "html": "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>",
  })
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Templates.update("34a080c9-b17d-4187-ad80-5af20266e535", {
    name: "order-confirmation",
    html: "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>"
  })
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	template, err := client.Templates.UpdateWithContext(context.TODO(), "34a080c9-b17d-4187-ad80-5af20266e535", &resend.UpdateTemplateRequest{
  		Name: "order-confirmation",
  		Html: "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>",
  	})
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    types::UpdateTemplateOptions,
    Resend, Result,
  };

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

    let name = "order-confirmation";
    let html = "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>";

    let update = UpdateTemplateOptions::new(name, html);

    let _template = resend
      .templates
      .update("34a080c9-b17d-4187-ad80-5af20266e535", update)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  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("<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>")
                  .build();

          UpdateTemplateResponseSuccess data = resend.templates().update("34a080c9-b17d-4187-ad80-5af20266e535", params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.TemplateUpdateAsync(
      templateId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
      new TemplateData()
      {
          HtmlBody = "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>",
      }
  );
  ```

  ```bash cURL theme={null}
  curl -X PATCH 'https://api.resend.com/templates/34a080c9-b17d-4187-ad80-5af20266e535' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "order-confirmation",
    "html": "<p>Total: {{{PRICE}}}</p><p>Name: {{{PRODUCT}}}</p>"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "id": "34a080c9-b17d-4187-ad80-5af20266e535",
    "object": "template"
  }
  ```
</ResponseExample>


# Create Topic
Source: https://resend.com/docs/api-reference/topics/create-topic

POST /topics
Create and email topics to segment your audience.

## Body Parameters

<ParamField type="string">
  The topic name. Max length is `50` characters.
</ParamField>

<ResendParamField type="string">
  The default subscription preference for new contacts. Possible values:
  `opt_in` or `opt_out`.

  <Note>
    This value cannot be changed later.
  </Note>
</ResendParamField>

<ParamField type="string">
  The topic description. Max length is `200` characters.
</ParamField>

<ResendParamField type="string">
  The visibility of the topic on the unsubscribe page. Possible values: `public` or `private`.

  * `private`: only contacts who are opted in to the topic can see it on the unsubscribe page.
  * `public`: all contacts can see the topic on the unsubscribe page.

  If not specified, defaults to `private`.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.topics.create({
    name: 'Weekly Newsletter',
    defaultSubscription: 'opt_in',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->topics->create([
    'name' => 'Weekly Newsletter',
    'default_subscription' => 'opt_in',
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Topics.create({
      "name": "Weekly Newsletter",
      "default_subscription": "opt_in",
      "description": "Subscribe to our weekly newsletter for updates",
  })
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Topics.create(
    name: "Weekly Newsletter",
    default_subscription: "opt_in"
  )
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	topic, err := client.Topics.CreateWithContext(context.TODO(), &resend.CreateTopicRequest{
  		Name:                "Weekly Newsletter",
  		DefaultSubscription: resend.DefaultSubscriptionOptIn,
  	})
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    types::{CreateTopicOptions, SubscriptionType},
    Resend, Result,
  };

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

    let opts = CreateTopicOptions::new("Weekly Newsletter", SubscriptionType::OptIn);
    let _topic = resend.topics.create(opts).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      CreateTopicOptions createTopicOptions = CreateTopicOptions.builder()
        .name("Weekly Newsletter")
        .defaultSubscription("opt_in")
        .build();

      CreateTopicResponseSuccess response = resend.topics().create(createTopicOptions);
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.TopicCreateAsync( new TopicData() {
    Name = "Weekly Newsletter",
    Description = "Weekly newsletter for our subscribers",
    SubscriptionDefault = SubscriptionType.OptIn,
  } );
  Console.WriteLine( "Topic Id={0}", resp.Content );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/topics' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "Weekly Newsletter",
    "default_subscription": "opt_in"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "topic",
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
  }
  ```
</ResponseExample>


# Delete Topic
Source: https://resend.com/docs/api-reference/topics/delete-topic

DELETE /topics/:topic_id
Remove an existing topic.

## Path Parameters

<ResendParamField type="string">
  The topic ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Topics.remove(id="b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Topics.remove("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	topic, err := client.Topics.RemoveWithContext(
  		context.TODO(),
  		"b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _deleted = resend.topics.delete("delete").await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      RemoveTopicResponseSuccess response = resend.topics().remove("b6d24b8e-af0b-4c3c-be0c-359bbd97381e");
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X DELETE 'https://api.resend.com/topics/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "topic",
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    "deleted": true
  }
  ```
</ResponseExample>


# Retrieve Topic
Source: https://resend.com/docs/api-reference/topics/get-topic

GET /topics/:topic_id
Retrieve a topic by its ID.

## Path Parameters

<ResendParamField type="string">
  The Topic ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Topics.get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Topics.get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	topic, err := client.Topics.GetWithContext(
  		context.TODO(),
  		"b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
  	)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _topic = resend
      .topics
      .get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      GetTopicResponseSuccess topic = resend.topics().get("b6d24b8e-af0b-4c3c-be0c-359bbd97381e");
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.TopicRetrieveAsync( new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ) );
  Console.WriteLine( "Topic Id={0}", resp.Content.Id );
  ```

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/topics/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "topic",
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    "name": "Weekly Newsletter",
    "description": "Weekly newsletter for our subscribers",
    "default_subscription": "opt_in",
    "visibility": "public",
    "created_at": "2023-04-08T00:11:13.110779+00:00"
  }
  ```
</ResponseExample>


# List Topics
Source: https://resend.com/docs/api-reference/topics/list-topics

GET /topics
Retrieve a list of topics for the authenticated user.

<QueryParams type="topics" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Topics.list()
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Topics.list()
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	topics, err := client.Topics.ListWithContext(context.TODO(), nil)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let _list = resend.topics.list(ListOptions::default()).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      ListTopicsResponseSuccess response = resend.topics().list();
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/topics' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
        "name": "Weekly Newsletter",
        "description": "Weekly newsletter for our subscribers",
        "default_subscription": "opt_in",
        "visibility": "public",
        "created_at": "2023-04-08T00:11:13.110779+00:00"
      }
    ]
  }
  ```
</ResponseExample>


# Update Topic
Source: https://resend.com/docs/api-reference/topics/update-topic

PATCH /topics/:topic_id
Update an existing topic.

## Path Parameters

<ResendParamField type="string">
  The Topic ID.
</ResendParamField>

## Body Parameters

<ParamField type="string">
  The topic name. Max length is `50` characters.
</ParamField>

<ParamField type="string">
  The topic description. Max length is `200` characters.
</ParamField>

<ResendParamField type="string">
  The visibility of the topic on the unsubscribe page. Possible values: `public` or `private`.

  * `private`: only contacts who are opted in to the topic can see it on the unsubscribe page.
  * `public`: all contacts can see the topic on the unsubscribe page.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.topics.update(
    'b6d24b8e-af0b-4c3c-be0c-359bbd97381e',
    {
      name: 'Weekly Newsletter',
      description: 'Weekly newsletter for our subscribers',
    },
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->topics->update('b6d24b8e-af0b-4c3c-be0c-359bbd97381e', [
    'name' => 'Weekly Newsletter',
    'description' => 'Weekly newsletter for our subscribers',
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Topics.update(
      id="b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
      params={
          "name": "Monthly Newsletter",
          "description": "Subscribe to our monthly newsletter for updates",
      }
  )
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Topics.update(
    topic_id: "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
    name: "Weekly Newsletter",
    description: "Weekly newsletter for our subscribers"
  )
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	topic, err := client.Topics.UpdateWithContext(context.TODO(), "b6d24b8e-af0b-4c3c-be0c-359bbd97381e", &resend.UpdateTopicRequest{
  		Name:        "Weekly Newsletter",
  		Description: "Weekly newsletter for our subscribers",
  	})
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::UpdateTopicOptions, Resend, Result};

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

    let update = UpdateTopicOptions::new()
      .with_name("Weekly Newsletter")
      .with_description("Weekly newsletter for our subscribers");

    let _topic = resend
      .topics
      .update("b6d24b8e-af0b-4c3c-be0c-359bbd97381e", update)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      UpdateTopicOptions updateTopicOptions = UpdateTopicOptions.builder()
        .name("Weekly Newsletter")
        .description("Weekly newsletter for our subscribers")
        .build();

      UpdateTopicResponseSuccess response = resend.topics().update(
        "b6d24b8e-af0b-4c3c-be0c-359bbd97381e",
        updateTopicOptions
      );
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.TopicUpdateAsync(
    new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ),
    new TopicData() {
      Name = "Weekly Newsletter",
      Description = "Weekly newsletter for our subscribers",
      SubscriptionDefault = SubscriptionType.OptIn,
    }
  );
  ```

  ```bash cURL theme={null}
  curl -X PATCH 'https://api.resend.com/topics/b6d24b8e-af0b-4c3c-be0c-359bbd97381e' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "Weekly Newsletter",
    "default_subscription": "opt_in"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "topic",
    "id": "b6d24b8e-af0b-4c3c-be0c-359bbd97381e"
  }
  ```
</ResponseExample>


# Create Webhook
Source: https://resend.com/docs/api-reference/webhooks/create-webhook

POST /webhooks
Create a webhook to receive real-time notifications about email events.

## Body Parameters

<ParamField type="string">
  The URL where webhook events will be sent.
</ParamField>

<ParamField type="string[]">
  Array of event types to subscribe to.

  <span />

  See [event types](/webhooks/event-types) for available options.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.webhooks.create({
    endpoint: 'https://example.com/handler',
    events: ['email.sent'],
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->webhooks->create([
    'endpoint' => 'https://example.com/handler',
    'events' => ['email.sent'],
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  params: resend.Webhooks.CreateParams = {
      "endpoint": "https://example.com/handler",
      "events": ["email.sent"],
  }

  webhook = resend.Webhooks.create(params=params)
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  params = {
    endpoint: 'https://example.com/handler',
    events: ['email.sent']
  }

  webhook = Resend::Webhooks.create(params)
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateWebhookRequest{
    Endpoint: "https://example.com/handler",
    Events:   []string{"email.sent"},
  }

  webhook, err := client.Webhooks.Create(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    events::EmailEventType::{EmailSent},
    types::CreateWebhookOptions,
    Resend, Result,
  };

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

    let events = [EmailSent];
    let opts = CreateWebhookOptions::new("https://example.com/handler", events);
    let _webhook = resend.webhooks.create(opts).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;
  import static com.resend.services.webhooks.model.WebhookEvent.*;

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

          CreateWebhookOptions options = CreateWebhookOptions.builder()
                .endpoint("https://example.com/handler")
                .events(EMAIL_SENT)
                .build();

          CreateWebhookResponseSuccess response = resend.webhooks().create(options);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var data = new WebhookData()
  {
      EndpointUrl = "https://example.com/handler",
      Events = [ WebhookEventType.EmailSent ],
      Status = WebhookStatus.Disabled,
  };

  var resp = await resend.WebhookCreateAsync( data );
  Console.WriteLine( "Webhook Id={0}", resp.Content.Id );
  Console.WriteLine( "Signing secret={0}", resp.Content.SigningSecret );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/webhooks' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d '{
    "endpoint": "https://example.com/handler",
    "events": ["email.sent"]
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "webhook",
    "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
    "signing_secret": "whsec_xxxxxxxxxx"
  }
  ```
</ResponseExample>


# Delete Webhook
Source: https://resend.com/docs/api-reference/webhooks/delete-webhook

DELETE /webhooks/:webhook_id
Remove an existing webhook.

## Path Parameters

<ResendParamField type="string">
  The Webhook ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.webhooks.remove(
    '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->webhooks->remove('4dd369bc-aa82-4ff3-97de-514ae3000ee0');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  webhook = resend.Webhooks.remove(webhook_id='4dd369bc-aa82-4ff3-97de-514ae3000ee0')
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  webhook = Resend::Webhooks.remove('4dd369bc-aa82-4ff3-97de-514ae3000ee0')
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  webhook, err := client.Webhooks.Remove("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _deleted = resend
      .webhooks
      .delete("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          RemoveWebhookResponseSuccess response = resend.webhooks().remove("4dd369bc-aa82-4ff3-97de-514ae3000ee0");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.WebhookDeleteAsync( new Guid( "d91cd9bd-1176-453e-8fc1-35364d380206" ) );
  ```

  ```bash cURL theme={null}
  curl -X DELETE 'https://api.resend.com/webhooks/4dd369bc-aa82-4ff3-97de-514ae3000ee0' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "webhook",
    "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
    "deleted": true
  }
  ```
</ResponseExample>


# Retrieve Webhook
Source: https://resend.com/docs/api-reference/webhooks/get-webhook

GET /webhooks/:webhook_id
Retrieve a single webhook for the authenticated user.

## Path Parameters

<ResendParamField type="string">
  The Webhook ID.
</ResendParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.webhooks.get(
    '4dd369bc-aa82-4ff3-97de-514ae3000ee0',
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->webhooks->get('4dd369bc-aa82-4ff3-97de-514ae3000ee0');
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  webhook = resend.Webhooks.get(webhook_id='4dd369bc-aa82-4ff3-97de-514ae3000ee0')
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  webhook = Resend::Webhooks.get('4dd369bc-aa82-4ff3-97de-514ae3000ee0')
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  webhook, err := client.Webhooks.Get("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    let _webhook = resend
      .webhooks
      .get("4dd369bc-aa82-4ff3-97de-514ae3000ee0")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          GetWebhookResponseSuccess webhook = resend.webhooks().get("4dd369bc-aa82-4ff3-97de-514ae3000ee0");
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/webhooks/4dd369bc-aa82-4ff3-97de-514ae3000ee0' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "webhook",
    "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
    "created_at": "2023-08-22T15:28:00.000Z",
    "status": "enabled",
    "endpoint": "https://example.com/handler",
    "events": ["email.sent"],
    "signing_secret": "whsec_xxxxxxxxxx"
  }
  ```
</ResponseExample>


# List Webhooks
Source: https://resend.com/docs/api-reference/webhooks/list-webhooks

GET /webhooks
Retrieve a list of webhooks for the authenticated user.

<QueryParams type="webhooks" />

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  webhooks = resend.Webhooks.list()
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  webhooks = Resend::Webhooks.list
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  webhooks, err := client.Webhooks.List()
  ```

  ```rust Rust theme={null}
  use resend_rs::{list_opts::ListOptions, Resend, Result};

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

    let _webhooks = resend.webhooks.list(ListOptions::default()).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          ListWebhooksResponseSuccess response = resend.webhooks().list();
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

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

  ```bash cURL theme={null}
  curl -X GET 'https://api.resend.com/webhooks' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "list",
    "has_more": false,
    "data": [
      {
        "id": "7ab123cd-ef45-6789-abcd-ef0123456789",
        "created_at": "2023-09-10T10:15:30.000Z",
        "status": "disabled",
        "endpoint": "https://first-webhook.example.com/handler",
        "events": ["email.sent"]
      },
      {
        "id": "4dd369bc-aa82-4ff3-97de-514ae3000ee0",
        "created_at": "2023-08-22T15:28:00.000Z",
        "status": "enabled",
        "endpoint": "https://second-webhook.example.com/receive",
        "events": ["email.received"]
      }
    ]
  }
  ```
</ResponseExample>


# Update Webhook
Source: https://resend.com/docs/api-reference/webhooks/update-webhook

PATCH /webhooks/:webhook_id
Update an existing webhook configuration.

## Path Parameters

<ResendParamField type="string">
  The Webhook ID.
</ResendParamField>

## Body Parameters

<ParamField type="string">
  The URL where webhook events will be sent.
</ParamField>

<ParamField type="string[]">
  Array of event types to subscribe to.

  <span />

  See [event types](/webhooks/event-types) for available options.
</ParamField>

<ParamField type="string">
  The webhook status. Can be either `enabled` or `disabled`.
</ParamField>

<RequestExample>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.webhooks.update(
    '430eed87-632a-4ea6-90db-0aace67ec228',
    {
      endpoint: 'https://new-webhook.example.com/handler',
      events: ['email.sent', 'email.delivered'],
      status: 'enabled',
    },
  );
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->webhooks->update('430eed87-632a-4ea6-90db-0aace67ec228', [
    'endpoint' => 'https://new-webhook.example.com/handler',
    'events' => ['email.sent', 'email.delivered'],
    'status' => 'enabled',
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  params: resend.Webhooks.UpdateParams = {
      "webhook_id": "430eed87-632a-4ea6-90db-0aace67ec228",
      "endpoint": "https://new-webhook.example.com/handler",
      "events": ["email.sent", "email.delivered"],
      "status": "enabled",
  }

  webhook = resend.Webhooks.update(params)
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  params = {
    webhook_id: '430eed87-632a-4ea6-90db-0aace67ec228',
    endpoint: 'https://new-webhook.example.com/handler',
    events: ['email.sent', 'email.delivered'],
    status: 'enabled'
  }

  webhook = Resend::Webhooks.update(params)
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  endpoint := "https://new-webhook.example.com/handler"
  status := "enabled"
  params := &resend.UpdateWebhookRequest{
    Endpoint: &endpoint,
    Events:   []string{"email.sent", "email.delivered"},
    Status:   &status,
  }

  webhook, err := client.Webhooks.Update("430eed87-632a-4ea6-90db-0aace67ec228", params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    events::EmailEventType::{EmailDelivered, EmailSent},
    types::{UpdateWebhookOptions, WebhookStatus},
    Resend, Result,
  };

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

    let events = [EmailSent, EmailDelivered];
    let opts = UpdateWebhookOptions::default()
      .with_endpoint("https://new-webhook.example.com/handler")
      .with_events(events)
      .with_status(WebhookStatus::Enabled);

    let _webhook = resend
      .webhooks
      .update("430eed87-632a-4ea6-90db-0aace67ec228", opts)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;
  import static com.resend.services.webhooks.model.WebhookEvent.*;

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

          UpdateWebhookOptions options = UpdateWebhookOptions.builder()
              .endpoint("https://new-webhook.example.com/handler")
              .events(EMAIL_SENT, EMAIL_DELIVERED)
              .status(WebhookStatus.ENABLED)
              .build();

          UpdateWebhookResponseSuccess response = resend.webhooks()
              .update("430eed87-632a-4ea6-90db-0aace67ec228", options);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.WebhookUpdateAsync(
      new Guid( "430eed87-632a-4ea6-90db-0aace67ec228" ),
      new WebhookData()
      {
        EndpointUrl = "https://new-webhook.example.com/handler",
        Events = [ WebhookEventType.EmailSent ],
        Status = WebhookStatus.Disabled,
      }
  );
  ```

  ```bash cURL theme={null}
  curl -X PATCH 'https://api.resend.com/webhooks/430eed87-632a-4ea6-90db-0aace67ec228' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d '{
    "endpoint": "https://new-webhook.example.com/handler",
    "events": ["email.sent", "email.delivered"],
    "status": "enabled"
  }'
  ```
</RequestExample>

<ResponseExample>
  ```json Response theme={null}
  {
    "object": "webhook",
    "id": "430eed87-632a-4ea6-90db-0aace67ec228"
  }
  ```
</ResponseExample>


# Introduction
Source: https://resend.com/docs/dashboard/api-keys/introduction

Visualize all the API Keys on the Resend Dashboard.

## What is an API Key

API Keys are secret tokens used to authenticate your requests. They are unique to your account and should be kept confidential.

## Add API Key

You can create a new API Key from the [API Key Dashboard](https://resend.com/api-keys).

1. Click **Create API Key**.
2. Give your API Key a name.
3. Select **Full access** or **Sending access** as the permission.
4. If you select **Sending access**, you can choose the domain you want to restrict access to.

<img alt="Add API Key" />

<Note>
  For security reasons, you can only view the API Key once. Learn more about
  [API key best practices](/knowledge-base/how-to-handle-api-keys).
</Note>

## Set API Key permissions

There are two different permissions of API Keys:

1. **Full access**: grants access to create, delete, get, and update any resource.
2. **Sending access**: grants access only to send emails.

With API Key permissions, you can isolate different application actions to different API Keys. Using multiple keys, you can view logs per key, detect possible abuse, and control the damage that may be done accidentally or maliciously.

## View all API Keys

The [API Dashboard](https://resend.com/api-keys) shows you all the API Keys you have created along with their details, including the **last time you used** an API Key.

Different color indicators let you quickly scan and detect which API Keys are being used and which are not.

<img alt="View All API Keys" />

## Edit API Key details

After creating an API Key, you can edit the following details:

* Name
* Permission
* Domain

To edit an API Key, click the **More options** <Icon icon="ellipsis" /> button and then **Edit API Key**.

<img alt="View Inactive API Key" />

<Info>You cannot edit an API Key value after it has been created.</Info>

## Delete inactive API Keys

If an API Key **hasn't been used in the last 30 days**, consider deleting it to keep your account secure.

<img alt="View Inactive API Key" />

You can delete an API Key by clicking the **More options** <Icon icon="ellipsis" /> button and then **Remove API Key**.

<img alt="Delete API Key" />

## View API Key logs

When visualizing an active API Key, you can see the **total number of requests** made to the key. For more detailed logging information, select the underlined number of requests to view all logs for that API Key.

<img alt="View Active API Key" />

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

<Info>Currently, exports are limited to admin users of your team.</Info>

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

<Note>
  All exports your team creates are listed in the
  [Exports](https://resend.com/exports) page under **Settings** > **Team** >
  **Exports**. Select any export to view its details page. All members of your
  team can view your exports, but only admins can download the data.
</Note>


# Managing Contacts
Source: https://resend.com/docs/dashboard/audiences/contacts

Learn how to work with Contacts with Resend.

Contacts in Resend are global entities linked to a specific email address. After adding Contacts, send [Broadcasts](/dashboard/broadcasts/introduction) to groups of Contacts.

<Tip>
  If you previously used our Audience model, learn how to [migrate to the new
  Contacts model](/dashboard/segments/migrating-from-audiences-to-segments).
</Tip>

## Add Contacts

You can add a Contact in three different ways: via API, CSV upload, or manually.

### 1. Add Contacts programmatically via API

You can add contacts programmatically using the [contacts](/api-reference/contacts/create-contact) endpoint.

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  resend.contacts.create({
    email: 'steve.wozniak@gmail.com',
    firstName: 'Steve',
    lastName: 'Wozniak',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->contacts->create(
    parameters: [
      'email' => 'steve.wozniak@gmail.com',
      'first_name' => 'Steve',
      'last_name' => 'Wozniak',
    ]
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Contacts.CreateParams = {
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
  }

  resend.Contacts.create(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
  }

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

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v2"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateContactRequest{
    Email:        "steve.wozniak@gmail.com",
    FirstName:    "Steve",
    LastName:     "Wozniak",
  }

  contact, err := client.Contacts.Create(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::ContactData, Resend, Result};

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

    let contact = ContactData::new("steve.wozniak@gmail.com")
      .with_first_name("Steve")
      .with_last_name("Wozniak");

    let _contact = resend
      .contacts
      .create(contact)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          CreateContactOptions params = CreateContactOptions.builder()
                  .email("steve.wozniak@gmail.com")
                  .firstName("Steve")
                  .lastName("Wozniak")
                  .build();

          CreateContactResponseSuccess data = resend.contacts().create(params);
      }
  }
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/contacts' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak"
  }'
  ```
</CodeGroup>

When creating a Contact, you can optionally set the following properties:

* `first_name`: The first name of the contact.
* `last_name`: The last name of the contact.
* `unsubscribed`: Whether the contact is unsubscribed from all Broadcasts.
* `properties`: A map of custom property keys and values to create (learn more about [custom properties](/dashboard/audiences/properties)).

Once a Contact is created, you can update it using the [update contact](/api-reference/contacts/update-contact) endpoint or [add the contact to a Segment](/api-reference/contacts/add-contact-to-segment).

### 2. Add Contacts by uploading a .csv

You can also add Contacts by uploading a .csv file. This is a convenient way to add multiple Contacts at once.

1. Go to the [Contacts](https://resend.com/audience) page, and select **Add Contacts**.
2. Select **Import CSV**.
3. Upload your CSV file from your computer.
4. Map the fields you want to use. You can map the fields to: `email`, `first_name`, `last_name`, and `unsubscribed`, or any Contact properties you've already created.
5. Optionally add the contacts to an existing Segment.
6. Select **Continue**, review the contacts, and finish the upload.

### 3. Add Contacts manually

1. Go to the [Contacts](https://resend.com/audience) page, and select **Add Contacts**.
2. Select **Add Manually**.
3. Add the email address of the contact in the text field (separated by commas or new lines for multiple contacts).
4. Optionally add the contact to an existing Segment.
5. Confirm and click **Add**.

## Contact Properties

Contact Properties can be used to store additional information about your Contacts and then personalize your Broadcasts.

<img alt="Properties" />

Resend includes a few default properties:

* `first_name`: The first name of the contact.
* `last_name`: The last name of the contact.
* `unsubscribed`: Whether the contact is unsubscribed from all Broadcasts.
* `email`: The email address of the contact.

You can create additional custom Contact Properties for your Contacts to store additional information. These properties can be used to personalize your Broadcasts across all Segments.

Learn more about [Contact Properties](/dashboard/audiences/properties).

## View Contacts

You can view your Contacts in the [Contacts](https://resend.com/audience) page.

1. Go to the [Contacts](https://resend.com/audience) page.
2. Click on the Contact you want to view.
3. View the Contact details.

Each Contact includes the metadata associated with the contact, as well as a full history of all marketing interactions with the Contact.

<img alt="View Contact" />

You can also retrieve a [single Contact](/api-reference/contacts/get-contact) or [list all Contacts](/api-reference/contacts/list-contacts) via the API or SDKs.

## Edit Contacts

1. Go to the [Contacts](https://resend.com/audience) page.
2. Click on the **More options** <Icon icon="ellipsis" /> button and then **Edit Contact**.
3. Edit the Contact details and choose **Save**.

You can edit any Contact property (excluding the email address), assign
the Contact to a [Segment](/dashboard/segments/introduction) or [Topic](/dashboard/topics/introduction), or unsubscribe the Contact from all Broadcasts.

You can also [update a Contact](/api-reference/contacts/update-contact) via the API or SDKs using the `id` or `email` of the Contact.

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Update by contact id
  const { data, error } = await resend.contacts.update({
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    unsubscribed: true,
  });

  // Update by contact email
  const { data, error } = await resend.contacts.update({
    email: 'acme@example.com',
    unsubscribed: true,
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Update by contact id
  $resend->contacts->update(
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    parameters: [
      'unsubscribed' => true
    ]
  );

  // Update by contact email
  $resend->contacts->update(
    email: 'acme@example.com',
    parameters: [
      'unsubscribed' => true
    ]
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  # Update by contact id
  params: resend.Contacts.UpdateParams = {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "unsubscribed": True,
  }

  resend.Contacts.update(params)

  # Update by contact email
  params: resend.Contacts.UpdateParams = {
    "email": "acme@example.com",
    "unsubscribed": True,
  }

  resend.Contacts.update(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  # Update by contact id
  params = {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "unsubscribed": true,
  }

  Resend::Contacts.update(params)

  # Update by contact email
  params = {
    "email": "acme@example.com",
    "unsubscribed": true,
  }

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

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  // Update by contact id
  params := &resend.UpdateContactRequest{
    Id:           "e169aa45-1ecf-4183-9955-b1499d5701d3",
    Unsubscribed: true,
  }
  params.SetUnsubscribed(true)

  contact, err := client.Contacts.Update(params)

  // Update by contact email
  params = &resend.UpdateContactRequest{
    Email:        "acme@example.com",
    Unsubscribed: true,
  }
  params.SetUnsubscribed(true)

  contact, err := client.Contacts.Update(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::ContactChanges, Resend, Result};

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

    let changes = ContactChanges::new().with_unsubscribed(true);

    // Update by contact id
    let _contact = resend
      .contacts
      .update("e169aa45-1ecf-4183-9955-b1499d5701d3", changes.clone())
      .await?;

    // Update by contact email
    let _contact = resend
      .contacts
      .update("acme@example.com", changes)
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          // Update by contact id
          UpdateContactOptions params = UpdateContactOptions.builder()
                  .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
                  .unsubscribed(true)
                  .build();

          // Update by contact email
          UpdateContactOptions params = UpdateContactOptions.builder()
                  .email("acme@example.com")
                  .unsubscribed(true)
                  .build();

          UpdateContactResponseSuccess data = resend.contacts().update(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  // By Id
  await resend.ContactUpdateAsync(
      contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
      new ContactData()
      {
          FirstName = "Stevie",
          LastName = "Wozniaks",
          IsUnsubscribed = true,
      }
  );

  // By Email
  await resend.ContactUpdateByEmailAsync(
      "acme@example.com",
      new ContactData()
      {
          FirstName = "Stevie",
          LastName = "Wozniaks",
          IsUnsubscribed = true,
      }
  );
  ```

  ```bash cURL theme={null}
  # Update by contact id
  curl -X PATCH 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "unsubscribed": true
  }'

  # Update by contact email
  curl -X PATCH 'https://api.resend.com/contacts/acme@example.com' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "unsubscribed": true
  }'
  ```
</CodeGroup>

## Delete Contacts

1. Go to the [Contacts](https://resend.com/audience) page.
2. Click on the **More options** <Icon icon="ellipsis" /> button and then **Delete Contact**.
3. Confirm the deletion.

You can also [delete a Contact](/api-reference/contacts/delete-contact) via the API or SDKs.

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Delete by contact id
  const { data, error } = await resend.contacts.remove({
    id: '520784e2-887d-4c25-b53c-4ad46ad38100',
  });

  // Delete by contact email
  const { data, error } = await resend.contacts.remove({
    email: 'acme@example.com',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Delete by contact id
  $resend->contacts->remove(
    id: '520784e2-887d-4c25-b53c-4ad46ad38100'
  );

  // Delete by contact email
  $resend->contacts->remove(
    email: 'acme@example.com'
  );
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  # Delete by contact id
  resend.Contacts.remove(
    id="520784e2-887d-4c25-b53c-4ad46ad38100"
  )

  # Delete by contact email
  resend.Contacts.remove(
    email="acme@example.com"
  )
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  # Delete by contact id
  Resend::Contacts.remove(
    "520784e2-887d-4c25-b53c-4ad46ad38100"
  )

  # Delete by contact email
  Resend::Contacts.remove(
    email: "acme@example.com",
  )
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  // Delete by contact id
  removed, err := client.Contacts.Remove(
    "520784e2-887d-4c25-b53c-4ad46ad38100"
  )

  // Delete by contact email
  removed, err := client.Contacts.Remove(
    "acme@example.com"
  )
  ```

  ```rust Rust theme={null}
  use resend_rs::{Resend, Result};

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

    // Delete by contact id
    let _deleted = resend
      .contacts
      .delete("520784e2-887d-4c25-b53c-4ad46ad38100")
      .await?;

    // Delete by contact email
    let _deleted = resend
      .contacts
      .delete("acme@example.com")
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          // Delete by contact id
          resend.contacts().remove(ContactRequestOptions.builder()
                          .id("520784e2-887d-4c25-b53c-4ad46ad38100")
                          .build());

          // Delete by contact email
          resend.contacts().remove(ContactRequestOptions.builder()
                          .email("acme@example.com")
                          .build());
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  // By Id
  await resend.ContactDeleteAsync(
      contactId: new Guid( "520784e2-887d-4c25-b53c-4ad46ad38100" )
  );

  // By Email
  await resend.ContactDeleteByEmailAsync(
      "acme@example.com"
  );
  ```

  ```bash cURL theme={null}
  # Delete by contact id
  curl -X DELETE 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
       -H 'Authorization: Bearer re_xxxxxxxxx'

  # Deleted by contact email
  curl -X DELETE 'https://api.resend.com/contacts/acme@example.com' \
       -H 'Authorization: Bearer re_xxxxxxxxx'
  ```
</CodeGroup>


# Your Resend Audience
Source: https://resend.com/docs/dashboard/audiences/introduction

Learn how to manage your Contacts and send personalized Broadcasts to them.

The [Audience Page](https://resend.com/audience) is for your marketing Broadcasts and provides tools for managing your Contacts and sending personalized Broadcasts to them. [Broadcasts](/dashboard/broadcasts/introduction) also handle all your unsubscribe flows for you automatically.

The Audience page includes four areas:

* [Contacts](#contacts): individual email addresses
* [Properties](#properties): custom properties for your Contacts
* [Segments](#segments): groups of Contacts for your organization
* [Topics](#topics): user-facing tools for managing email preferences

<img alt="Contacts" />

## Contacts

Contacts in Resend are global entities linked to a specific email address.

<img alt="Properties" />

Each Contact:

* is associated with a single email address
* can have custom properties
* can be in zero, one or multiple Segments
* can be opted in or out of Topics

Each Contact shows a history of all marketing interactions with the Contact.

Learn more about [Contacts](/dashboard/audiences/contacts).

## Properties

Contact Properties can be used to store additional information about your Contacts and then personalize your Broadcasts.

<img alt="Properties" />

Resend includes a few default properties:

* `first_name`: The first name of the contact.
* `last_name`: The last name of the contact.
* `unsubscribed`: Whether the contact is unsubscribed from all Broadcasts.
* `email`: The email address of the contact.

You can create additional custom Contact Properties for your Contacts to store additional information. These properties can be used to personalize your Broadcasts across all Segments.

Learn more about [Contact Properties](/dashboard/audiences/properties).

## Segments

Segments are groups of Contacts for your organization. You can use Segments to send emails to a specific group of Contacts using [Broadcasts](/dashboard/broadcasts/introduction).

<img alt="Segment" />

Learn more about [Segments](/dashboard/segments/introduction).

## Topics

Topics are user-facing tools for managing email preferences. You can use them to manage your Contacts' email preferences.

<img alt="Topics" />

When you send [Broadcasts](/dashboard/broadcasts/introduction), you can optionally scope sending to a particular Topic. Not only does scoping your sending help you send more precisely, but it also allows your users to manage their preferences with more control.

Learn more about [Topics](/dashboard/topics/introduction).

<Info>
  You can [customize your unsubscribe page with your
  branding](/dashboard/settings/unsubscribe-page) from your team settings.
</Info>


# Managing Unsubscribed Contacts
Source: https://resend.com/docs/dashboard/audiences/managing-unsubscribe-list

Learn how to check and remove recipients who have unsubscribed to your marketing emails.

It's essential to update your Contact list when someone unsubscribes to maintain a good sender reputation.

Benefits of managing your unsubscribe list:

* reduces the likelihood of your emails being marked as spam
* improves deliverability for any other marketing or transactional emails you send

When you include an [an unsubscribe link in your Broadcasts](/dashboard/segments/introduction#automatic-unsubscribes), Resend will automatically handle the unsubscribe flow for you.

## Unsubscribe Statuses

The Contacts page shows the global unsubscribe status of each Contact.

<img alt="Unsubscribe Statuses" />

* **Unsubscribed**: the Contact has unsubscribed from all emails from your account.
* **Subscribed**: the Contact is subscribed to at least one Topic.

To filter by Status, click on the **All Statuses** filter next to the search bar, then select a value.

## Topic Subscription Statuses

You can view the subscription status of each Topic for a given Contact by clicking on the Contact's row.

<img alt="Topic Subscription Statuses" />

* **Subscribed**: the global subscription status for the Contact.
* **Topics**: the list of Topics the Contact is subscribed to.

You can also check a Contact's Topic subscription status [via the API or SDKs](/api-reference/contacts/get-contact-topics).

## Updating a Topic Subscription for a Contact

You can update a Topic subscription for a Contact by clicking the **Edit** button in the Topic's row.

<img alt="Add Contact to Topic" />

You can also update a Topic subscription for a Contact [via the API or SDKs](/api-reference/contacts/update-contact-topics).


# Contact Properties
Source: https://resend.com/docs/dashboard/audiences/properties

Learn how to work with Contact Properties with Resend.

Contact Properties can be used to store additional information about your Contacts and then personalize your Broadcasts.

Resend includes a few default properties:

* `first_name`: The first name of the contact.
* `last_name`: The last name of the contact.
* `unsubscribed`: Whether the contact is unsubscribed from all Broadcasts.
* `email`: The email address of the contact.

## Add Custom Contact Properties

You can create additional custom Contact Properties for your Contacts to store additional information. These properties can be used to personalize your Broadcasts across all Segments.

Each Contact Property has a key, a value, and optional fallback value.

* `key`: The key of the property (must be alphanumeric and underscore only, max `50` characters).
* `value`: The value of the property (may be a `string` or `number`).
* `fallback_value`: The fallback value of the property (must match the type of the property).

<video />

You can also create Contact Properties [via the API or SDKs](/api-reference/contact-properties/create-contact-property).

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.contactProperties.create({
    key: 'company_name',
    type: 'string',
    fallbackValue: 'Acme Corp',
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->contactProperties->create([
    'key' => 'company_name',
    'type' => 'string',
    'fallback_value' => 'Acme Corp',
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = 're_xxxxxxxxx'

  params = {
      "key": "company_name",
      "type": "string",
      "fallback_value": "Acme Corp",
  }

  contact_property = resend.ContactProperties.create(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  property = Resend::ContactProperties.create({
    key: "company_name",
    type: "string",
    fallback_value: "Acme Corp"
  })
  ```

  ```go Go theme={null}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

  func main() {
  	ctx := context.TODO()
  	apiKey := "re_xxxxxxxxx"

  	client := resend.NewClient(apiKey)

  	params := &resend.CreateContactPropertyRequest{
  		Key:           "company_name",
  		Type:          "string",
  		FallbackValue: "Acme Corp",
  	}

  	property, err := client.ContactProperties.CreateWithContext(ctx, params)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(property)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    types::{CreateContactPropertyOptions, PropertyType},
    Resend, Result,
  };

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

    let contact_property = CreateContactPropertyOptions::new("company_name", PropertyType::String)
      .with_fallback("Acme Corp");

    let _contact_property = resend.contacts.create_property(contact_property).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

      CreateContactPropertyOptions options = CreateContactPropertyOptions.builder()
        .key("company_name")
        .type("string")
        .fallbackValue("Acme Corp")
        .build();

      resend.contactProperties().create(options);
    }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.ContactPropCreateAsync( new ContactPropertyData() {
    Key = "company_name",
    PropertyType = ContactPropertyType.String,
    DefaultValue = "Acme Corp",
  } );
  Console.WriteLine( "Prop Id={0}", resp.Content );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/contact-properties' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "key": "company_name",
    "type": "string",
    "fallback_value": "Acme Corp"
  }'
  ```
</CodeGroup>

## Add Properties to a Contact

When you create a Contact Property you can provide a fallback value. This value will be used whenever you don't provide a custom value for a Contact.

To provide a custom value for a Contact, you can use the dashboard:

1. Go to the [Contacts](https://resend.com/audience) page.
2. Click the **more options** <Icon icon="ellipsis" /> button and then **Edit Contact**.
3. Add the property key and value.
4. Click on the **Save** button.

<video />

You can also add properties to a Contact when you [create a Contact](/api-reference/contacts/create-contact).

<CodeGroup>
  ```ts Node.js {10-12} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.contacts.create({
    email: 'steve.wozniak@gmail.com',
    firstName: 'Steve',
    lastName: 'Wozniak',
    unsubscribed: false,
    properties: {
      company_name: 'Acme Corp',
    },
  });
  ```

  ```php PHP {9-11} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->contacts->create(
    parameters: [
      'email' => 'steve.wozniak@gmail.com',
      'first_name' => 'Steve',
      'last_name' => 'Wozniak',
      'unsubscribed' => false,
      'properties' => [
        'company_name' => 'Acme Corp',
      ]
    ]
  );
  ```

  ```python Python {10-12} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Contacts.CreateParams = {
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
    "unsubscribed": False,
    "properties": {
      "company_name": "Acme Corp"
    }
  }

  resend.Contacts.create(params)
  ```

  ```ruby Ruby {10-12} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
    "unsubscribed": false,
    "properties": {
      "company_name": "Acme Corp",
    }
  }

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

  ```go Go {10-12} theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateContactRequest{
    Email:        "steve.wozniak@gmail.com",
    FirstName:    "Steve",
    LastName:     "Wozniak",
    Unsubscribed: false,
    Properties: map[string]interface{} {
      "company_name": "Acme Corp",
    }
  }

  contact, err := client.Contacts.Create(params)
  ```

  ```rust Rust {11-12} theme={null}
  use resend_rs::{types::CreateContactOptions, Resend, Result};

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

    let contact = CreateContactOptions::new("steve.wozniak@gmail.com")
      .with_first_name("Steve")
      .with_last_name("Wozniak")
      .with_unsubscribed(false)
      .with_properties(vec![("company_name".to_string(), "Acme Corp".to_string())]);

    let _contact = resend.contacts.create(contact).await?;

    Ok(())
  }
  ```

  ```java Java {12-13} theme={null}
  import com.resend.*;

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

          CreateContactOptions params = CreateContactOptions.builder()
                  .email("steve.wozniak@gmail.com")
                  .firstName("Steve")
                  .lastName("Wozniak")
                  .unsubscribed(false)
                  .properties(java.util.Map.of("company_name", "Acme Corp"))
                  .build();

          CreateContactResponseSuccess data = resend.contacts().create(params);
      }
  }
  ```

  ```csharp .NET {12-14} theme={null}
  using Resend;

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

  var resp = await resend.ContactAddAsync(
      new ContactData()
      {
          Email = "steve.wozniak@gmail.com",
          FirstName = "Steve",
          LastName = "Wozniak",
          IsUnsubscribed = false,
          Properties = new Dictionary<string, object> {
            { "company_name", "Acme Corp" }
          }
      }
  );
  Console.WriteLine( "Contact Id={0}", resp.Content );
  ```

  ```bash cURL {9-11} theme={null}
  curl -X POST 'https://api.resend.com/contacts' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "email": "steve.wozniak@gmail.com",
    "first_name": "Steve",
    "last_name": "Wozniak",
    "unsubscribed": false,
    "properties": {
      "company_name": "Acme Corp",
    }
  }'
  ```
</CodeGroup>

Or you can update a Contact to add or change a property value [using the update contact endpoint](/api-reference/contacts/update-contact).

<CodeGroup>
  ```ts Node.js {8-10, 16-18} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  // Update by contact id
  const { data, error } = await resend.contacts.update({
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    properties: {
      company_name: 'Acme Corp',
    },
  });

  // Update by contact email
  const { data, error } = await resend.contacts.update({
    email: 'acme@example.com',
    properties: {
      company_name: 'Acme Corp',
    },
  });
  ```

  ```php PHP {7-9, 17-19} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Update by contact id
  $resend->contacts->update(
    id: 'e169aa45-1ecf-4183-9955-b1499d5701d3',
    parameters: [
      'properties' => [
        'company_name' => 'Acme Corp',
      ]
    ]
  );

  // Update by contact email
  $resend->contacts->update(
    email: 'acme@example.com',
    parameters: [
      'properties' => [
        'company_name' => 'Acme Corp',
      ]
    ]
  );
  ```

  ```python Python {8-10, 18-20} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  # Update by contact id
  params: resend.Contacts.UpdateParams = {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "properties": {
      "company_name": "Acme Corp",
    }
  }

  resend.Contacts.update(params)

  # Update by contact email
  params: resend.Contacts.UpdateParams = {
    "email": "acme@example.com",
    "properties": {
      "company_name": "Acme Corp",
    }
  }

  resend.Contacts.update(params)
  ```

  ```ruby Ruby {8-10, 18-20} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  # Update by contact id
  params = {
    "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
    "properties": {
      "company_name": "Acme Corp",
    }
  }

  Resend::Contacts.update(params)

  # Update by contact email
  params = {
    "email": "acme@example.com",
    "properties": {
      "company_name": "Acme Corp",
    }
  }

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

  ```go Go {8-10, 19-21} theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  // Update by contact id
  params := &resend.UpdateContactRequest{
    Id:           "e169aa45-1ecf-4183-9955-b1499d5701d3",
    Properties: new Dictionary<string, object> {
      { "company_name", "Acme Corp" }
    }
  }
  params.SetUnsubscribed(true)

  contact, err := client.Contacts.Update(params)

  // Update by contact email
  params = &resend.UpdateContactRequest{
    Email:        "acme@example.com",
    Properties: new Dictionary<string, object> {
      { "company_name", "Acme Corp" }
    }
  }
  params.SetUnsubscribed(true)

  contact, err := client.Contacts.Update(params)
  ```

  ```rust Rust {7} theme={null}
  use resend_rs::{types::ContactChanges, Resend, Result};

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

    let changes = ContactChanges::new().with_properties(vec![("company_name".to_string(), "Acme Corp".to_string())]);

    // Update by contact id
    let _contact = resend
      .contacts
      .update("e169aa45-1ecf-4183-9955-b1499d5701d3", changes.clone())
      .await?;

    // Update by contact email
    let _contact = resend
      .contacts
      .update("acme@example.com", changes)
      .await?;

    Ok(())
  }
  ```

  ```java Java {10, 16} theme={null}
  import com.resend.*;

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

          // Update by contact id
          UpdateContactOptions params = UpdateContactOptions.builder()
                  .id("e169aa45-1ecf-4183-9955-b1499d5701d3")
                  .properties(vec![("company_name".to_string(), "Acme Corp".to_string())])
                  .build();

          // Update by contact email
          UpdateContactOptions params = UpdateContactOptions.builder()
                  .email("acme@example.com")
                  .properties(vec![("company_name".to_string(), "Acme Corp".to_string())])
                  .build();

          UpdateContactResponseSuccess data = resend.contacts().update(params);
      }
  }
  ```

  ```csharp .NET {12-14, 25-27} theme={null}
  using Resend;

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

  // By Id
  await resend.ContactUpdateAsync(
      contactId: new Guid( "e169aa45-1ecf-4183-9955-b1499d5701d3" ),
      new ContactData()
      {
          FirstName = "Stevie",
          LastName = "Wozniaks",
          Properties = new Dictionary<string, object> {
            { "company_name", "Acme Corp" }
          }
      }
  );

  // By Email
  await resend.ContactUpdateByEmailAsync(
      "acme@example.com",
      new ContactData()
      {
          FirstName = "Stevie",
          LastName = "Wozniaks",
          Properties = new Dictionary<string, object> {
            { "company_name", "Acme Corp" }
          }
      }
  );
  ```

  ```bash cURL {6-8, 16-18} theme={null}
  # Update by contact id
  curl -X PATCH 'https://api.resend.com/contacts/520784e2-887d-4c25-b53c-4ad46ad38100' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "properties": {
      "company_name": "Acme Corp",
    }
  }'

  # Update by contact email
  curl -X PATCH 'https://api.resend.com/contacts/acme@example.com' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "properties": {
      "company_name": "Acme Corp",
    }
  }'
  ```
</CodeGroup>

When you create or update a Contact with properties, the properties are added to the Contact, but only if the property key already exists and the value type is valid. You can [list all Contact Properties](/api-reference/contact-properties/list-contact-properties) to see all available properties.

<AccordionGroup>
  <Accordion title="What happens if the properties don't exist?">
    If the properties don't exist, they are not added to the Contact and the
    call fails. An error is returned.
  </Accordion>

  <Accordion title="Property keys are case sensitive, right?">
    Yes, property keys are case sensitive. If you create a property with a key
    of "company\_name", you cannot use "CompanyName" or "company\_Name" in your
    Contacts.
  </Accordion>

  <Accordion title="What happens if the value isn't the right type?">
    If the value isn't the right type, the property value is not added to the
    Contact and the call fails. An error is returned.
  </Accordion>
</AccordionGroup>

## Use Contact Properties in Broadcasts

You can use Contact Properties in your Broadcasts to personalize your emails.

<video />

You can also use Contact Properties in your Broadcast HTML and Text content when you [create a Broadcast using the API or SDKs](/api-reference/broadcasts/create-broadcast).


# Managing Broadcasts
Source: https://resend.com/docs/dashboard/broadcasts/introduction

Send marketing emails efficiently without code.

Broadcasts allow you to send email blasts to your customers using a no-code editor on Resend, or from our [Broadcast API](/api-reference/broadcasts/create-broadcast).

You can use this to send email blasts such as:

* Newsletters
* Product Launches
* Investor Updates
* Promotions
* Changelogs

## Sending a Broadcast from Resend

Our Broadcasts feature was made to enable your entire team to send email campaigns without having to ask for help from developers.

### No-Code Editor

<video />

### Markdown Support

You can also write your emails using Markdown. This works with headings, lists, italic, bold, links, and quotes.

You can easily copy and paste content from applications like Notion, Google Docs, iA Writter and many others maintaining formatting consistency.

<video />

### Custom Styling

You can customize the look and feel of your email by changing **global styles** such as the background color, link color, and container size, allowing you to create emails aligned with your brand identity.

To do this, click on **Styles** at the top left of the Broadcast editor. You can edit specific images or lines of texts by selecting or highlighting them prior to clicking on **Styles**.

<video />

You can also edit individual styles for each component, including the font size, font weight, and text alignment. You can also set custom properties for each component, such as image alt, button links, and social links,

<video />

### Personalize your content

When creating broadcasts, you can include dynamic audience data to personalize the email content.

* `{{{FIRST_NAME|fallback}}}`
* `{{{LAST_NAME|fallback}}}`
* `{{{EMAIL}}}`
* `{{{RESEND_UNSUBSCRIBE_URL}}}`

When you include the `{{{RESEND_UNSUBSCRIBE_URL}}}` placeholder in the call, Resend includes an unsubscribe link in the email to automatically handle unsubscribe requests.

<Note>
  Learn how to create a [custom Unsubscribe
  Page](/dashboard/settings/unsubscribe-page).
</Note>

### Testing & Sending

Once you're finished writing your email, you can preview it in your personal inbox or send it to your team for feedback.

To do this, click on **Test Email** on the top right of your screen. Enter in the email address you'd like to send your email to, and then click on **Send Test Email** to complete.

Once you're ready to send your email to your Audience, click on **Send**, and slide to confirm.

<video />

**Note**: Test emails do not include any custom Reply-To address that may have been configured. This behavior is limited to test mode and does not affect actual email sends.

## Sending a Broadcast from the Broadcast API

We also offer the option to send your Broadcasts from our [Broadcast API](/api-reference/broadcasts/create-broadcast).

The Broadcast API offers 6 endpoints for programmatically creating, updating, and sending broadcasts.

## Understand broadcast statuses

Here are all the statuses that can be associated with a broadcast:

* `draft` - The broadcast is a draft (note: if a broadcast is scheduled, it will be in the `draft` status until the scheduled time).
* `sent` - The broadcast was sent.
* `queued` - The broadcast is queued for delivery.

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

<Info>Currently, exports are limited to admin users of your team.</Info>

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

<Note>
  All exports your team creates are listed in the
  [Exports](https://resend.com/exports) page under **Settings** > **Team** >
  **Exports**. Select any export to view its details page. All members of your
  team can view your exports, but only admins can download the data.
</Note>


# Performance Tracking
Source: https://resend.com/docs/dashboard/broadcasts/performance-tracking

Track your Broadcasts email performance in real-time

Once your broadcast is sent, you can track its performance right away. The insights you can view are emails delivered, unsubscribed, click rate, and open rate.

You can view these insights by clicking on [Broadcast](https://resend.com/broadcasts) in the left column, and then clicking on the Broadcast that you want to view.

<video />

Please note, at times, open rates can be inaccurate for a number of reasons due to the way inbox providers handle incoming emails. You can [read more about this here.](https://resend.com/docs/knowledge-base/why-are-my-open-rates-not-accurate)


# Implementing BIMI
Source: https://resend.com/docs/dashboard/domains/bimi

Set up BIMI to gain brand recognition by displaying your logo in the inbox.

## Prerequisites

To get the most out of this guide, you will need to:

* Establish verifiable use of your logo
  * Obtain a registered trademark for your logo
  * Or, use your logo for over one year
* [Add a DMARC record on your domain](/dashboard/domains/dmarc)

## What is BIMI?

BIMI ([Brand Indicators for Message Identification](https://bimigroup.org/)) is a standard that allows you to specify a logo (and sometimes a checkmark) to display next to your email in the inbox. These indicators can increase brand recognition and trust and improve engagement.

<img alt="bimi-example" />

Though this standard is newer, most major mailbox providers now support it. This gives BIMI adoption a competitive edge for brand recognition in the inbox. Most mailbox providers show brand indicators for those who purchase a certificate, of which there are two types: a Common Mark Certificate (CMC) and a Verified Mark Certificate (VMC).

Here's an overview of current email client support:

| Client                                                | BIMI w/a CMC | BIMI w/a VMC | BIMI w/out a VMC or CMC |
| ----------------------------------------------------- | ------------ | ------------ | ----------------------- |
| [Apple Mail](https://support.apple.com/en-us/108340)  | X            | ✓            | X                       |
| [Gmail](https://support.google.com/a/answer/10911320) | ✓            | ✓            | X                       |
| Outlook                                               | X            | X            | X                       |
| [Yahoo](https://senders.yahooinc.com/bimi/)           | ✓            | ✓            | ✓                       |

## Implementing BIMI

### 1. Configure DMARC

<Note>
  If you haven't set up DMARC yet, follow our [DMARC Setup
  Guide](/dashboard/domains/dmarc).
</Note>

BIMI requires a DMARC policy of `p=quarantine;` or `p=reject;`. This policy assures that your emails are properly authenticated and that no one else can spoof your domain and send them with your logo.

Here's an overview of the required parameters:

| Parameter | Purpose    | Required Value                 |
| --------- | ---------- | ------------------------------ |
| `p`       | Policy     | `p=quarantine;` or `p=reject;` |
| `pct`     | Percentage | `pct=100;`                     |

Here is an example of an adequate DMARC record:

```
"v=DMARC1; p=quarantine; pct=100; rua=mailto:dmarcreports@example.com"
```

<Note>
  For BIMI on a subdomain, the root or APEX domain must also have a DMARC policy
  of `p=quarantine` or `p=reject` in addition to the subdomain. If not, the
  subdomain will not be compliant to display a BIMI logo.
</Note>

### 2. Establish verifiable use of your logo

To display your logo in most email clients using BIMI, you need to prove ownership of your logo by obtaining a mark certificate. This process is similar to acquiring an SSL certificate for your website. You can purchase a mark certificate from various authorized vendors. We recommend [DigiCert](https://www.digicert.com/).

There are two possible mark Certificate's to verify the use of your logo:

* **Verified Mark Certificate (VMC)**: A certificate issued by a Certificate Authority (CA) that is used to verify that you are the owner of the logo you are trying to display. A VMC is available if you have a trademark of your logo. With a VMC, Gmail will display a blue checkmark.
* **Common Mark Certificate (CMC)**: A certificate also issued by Certificate Authority (CA) to verify you. A CMC is available to you if you can establish that you’ve used your logo for one year. Currently, only Gmail supports a CMC.

A VMC offers the widest email client support, though the barrier of a trademark means a CMC is an easier path if you have established use of your logo for one year.

Here are a some things to know before starting the certificate purchase process:

* If you don't hold a trademark for your logo or have not used your logo for a year, you will not be able to purchase a certificate.
* The process could take weeks, so start early and respond to their requests quickly.
* You will need to provide a [SVG Tiny P/S formatted logo](https://bimigroup.org/creating-bimi-svg-logo-files/).
* You will need to prove you own the domain by adding a DNS record.
* You will need to prove you are the owner of the trademark or logo by providing identification.
* You will need publicly available proof that your business exists. For newer startups, recommend [Yellow Pages](https://marketing.yellowpages.com/en/) or [Google Business Profiles](https://support.google.com/business/answer/3039617?hl=en) as the easiest method for proving your existence

## 3. Set your BIMI DNS Record

Once you have your VMC, you can set your BIMI DNS record. This TXT record points to the location of your VMC and your logo.

| Name           | Type | Value                                               |
| -------------- | ---- | --------------------------------------------------- |
| default.\_bimi | TXT  | v=BIMI1; l=link\_to\_logo; a=link\_to\_certificate; |

Here is an example of a BIMI record:

```
v=BIMI1; l=https://vmc.digicert.com/00-00.svg; a=https://vmc.digicert.com/00-00.pem;
```

<Tip>
  Ensure your logo uses an HTTPS URL. Mailbox providers will not display the
  logo if served from an HTTP URL.
</Tip>

It contains a publicly and programmatically accessible link to your verified logo (.svg) and a link to your VMC (.pem).

To confirm that your BIMI record is published correctly, the [BIMI working group offers a tool](https://bimigroup.org/bimi-generator/) to check it.

It often takes a few days for your logo to display in inboxes after this record propagates. Mailbox providers will also conditionally decide to show the logo based on the domain's sending email volume and reputation. A domain with a high spam or bounce rate may not have their avatar displayed.

## Reference

| Parameter | Purpose             | Example                                |
| --------- | ------------------- | -------------------------------------- |
| `v`       | The version of BIMI | `v=BIMI1`                              |
| `l`       | Logo                | `l=https://vmc.digicert.com/00-00.svg` |
| `a`       | Certificate         | `a=https://vmc.digicert.com/00-00.pem` |
| `s`       | Selector            | `s=springlogo`                         |

<Tip>
  The BIMI standard allows for multiple logos using the [selector
  parameter](https://bimigroup.org/how-and-why-to-implement-bimi-selectors/).
</Tip>

<Note>
  Having issues setting up BIMI? [We can help](https://resend.com/help).
</Note>


# Implementing DMARC
Source: https://resend.com/docs/dashboard/domains/dmarc

Implement DMARC to build trust in your domain and protect against email spoofing and unauthorized use of your domain in email messages.

## Prerequisites

Since DMARC relies on DKIM and SPF, first ensure your existing emails are passing SPF and DKIM.

* DKIM verifies the email wasn't altered in transit using cryptographic authentication.
* SPF authorizes IP addresses to send email for a domain.

If you have a [verified](/dashboard/domains/introduction) domain with Resend, it means you are already passing SPF and DKIM

## What is DMARC?

DMARC ([Domain-based Message Authentication, Reporting, and Conformance](https://dmarc.org/overview/)) is an email authentication protocol that instructs mail servers what to do if an email message fails SPF and DKIM, preventing email spoofing (forged headers). DMARC is added to a domain through a TXT record added to the domain at `_dmarc`.

By preventing spoofing, a domain can build trust with mailbox providers, as it allows them to verify that emails are authorized to send on behalf of that domain.

An email must pass either SPF or DKIM checks (but not necessarily both) to achieve DMARC compliance and be considered authenticated. A message fails DMARC if both SPF and DKIM fail on the message.

## Implementing DMARC

### 1. Add a TXT `_dmarc` Record

To start, add a flexible DMARC record to your domain.

| Name                | Type | Value                                                       |
| ------------------- | ---- | ----------------------------------------------------------- |
| \_dmarc.example.com | TXT  | `v=DMARC1; p=none; rua=mailto:dmarcreports@yourdomain.com;` |

This record is specifying a few parameters (see [Reference](#reference) section for more details):

* `v` - Version:
  This is the version of DMARC
* `p` - Policy:
  This is telling the inbox how to process messages that fail DMARC. Options are `none`, `quarantine`, `reject`. It's a best practice to use `quarantine` or `reject`, but you should only do it once you know your messages are delivering and fully passing DMARC.
* `rua` - Reporting URI of Aggregate:
  Provide a **valid address** that can receive email. The address can be a different domain than the one on which you set the DMARC policy. The aggregate report comes as an email with a `.xml` file attached that shares the IP sources of your messages and if they passed SPF or DKIM.

To ensure you don't accidentally introduce breaking changes to your email sending, we suggest starting with a policy of `p=none;` before moving to a stricter policy.

### 2. Test to Confirm Delivery and Passing

To test emails, send an email from all the applications and services your domain uses. Confirm that the messages are delivered to the inbox and that the headers show DMARC passing. Spending a few at this step is a good rule of thumb to ensure you're checking all sources of email from your domain and catch email that is sent at a different cadence than daily.

To confirm DMARC passed, you can inspect the email headers and confirm there is `dmarc=pass`.

<Tip>
  Gradually identify email sources using tools like [Google Postmaster
  Tools](https://gmail.com/postmaster/), which provides DKIM/SPF feedback.
  [DMARC monitoring
  services](https://dmarc.org/resources/products-and-services/) can aggregate
  your email sources by collecting DMARC reports, helping you discover any
  services sending email on your domain's behalf.
</Tip>

### 3. Upgrade Policy

Once you have verified DMARC is passing across all your sending, you should upgrade your Policy to `p=quarantine;`. This policy gives mailbox providers greater confidence in your domain since your domain only allows authenticated email.

| Policy        | Value                                            |
| ------------- | ------------------------------------------------ |
| p=none;       | Allow all email. Monitoring for DMARC failures.  |
| p=quarantine; | Send messages that fail DMARC to the spam folder |
| p=reject;     | Bounce delivery of emails that fail DMARC.       |

Once your policy is `p=quarantine;` or `p=reject;` you can explore setting up [BIMI](/dashboard/domains/bimi), which can provide established brands even greater sending credibility by displaying a logo as an avatar in an email client.

## Reference

<Tip>
  While the DMARC protocol includes both `pct` and `ruf` parameters, they are
  not widely followed by mailbox providers. These settings may not be respected
  or followed.
</Tip>

| Parameter | Purpose                                       | Example                           |
| --------- | --------------------------------------------- | --------------------------------- |
| `v`       | Protocol version                              | `v=DMARC1`                        |
| `pct`     | Percentage of messages subjected to filtering | `pct=20`                          |
| `ruf`     | Reporting URI for forensic reports            | `ruf=mailto:authfail@example.com` |
| `rua`     | Reporting URI of aggregate reports            | `rua=mailto:aggrep@example.com`   |
| `p`       | Policy for organizational domain              | `p=quarantine`                    |
| `sp`      | Policy for subdomains of the OD               | `sp=reject`                       |
| `adkim`   | Alignment mode for DKIM                       | `adkim=s`                         |
| `aspf`    | Alignment mode for SPF                        | `aspf=r`                          |

<Note>
  Having issues setting up DMARC? [We can help](https://resend.com/help).
</Note>


# Managing Domains
Source: https://resend.com/docs/dashboard/domains/introduction

Visualize all the domains on the Resend Dashboard.

<Warning>
  Domain not verifying? [Try
  this](/knowledge-base/what-if-my-domain-is-not-verifying).
</Warning>

## Verifying a domain

Resend sends emails using a domain you own.

We recommend using subdomains (e.g., `updates.yourdomain.com`) to isolate your sending reputation and communicate your intent. Learn more about [using subdomains](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain).

In order to verify a domain, you must set two DNS entries:

1. [SPF](#what-are-spf-records): list of IP addresses authorized to send email on behalf of your domain
2. [DKIM](#what-are-dkim-records): public key used to verify email authenticity

These two DNS entries grant Resend permission to send email on your behalf. Once SPF and DKIM verify, you can optionally add a [DMARC record](/dashboard/domains/dmarc) to build additional trust with mailbox providers.

<Info>
  Resend requires you own your domain (i.e., not a shared or public domain).
</Info>

## View domain details

The [Domains dashboard](https://resend.com/domains) shows information about your domain name, its verification status, and history.

<img alt="Domain Details" />

<Info>
  Need specific help with a provider? View our [knowledge base DNS
  Guides](/knowledge-base).
</Info>

## What are SPF records

Sender Policy Framework (SPF) is an email authentication standard that allows you to list all the IP addresses that are authorized to send email on behalf of your domain.

The SPF configuration is made of a TXT record that lists the IP addresses approved by the domain owner. It also includes a MX record that allows the recipient to send bounce and complaint feedback to your domain.

<img alt="SPF Records" />

## Custom Return Path

By default, Resend will use the `send` subdomain for the Return-Path address. You can change this by setting the optional `custom_return_path` parameter when [creating a domain](/api-reference/domains/create-domain) via the API or under **Advanced options** in the dashboard.

<img alt="Custom Return Path" />

For the API, optionally pass the custom return path parameter.

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  resend.domains.create({ name: 'example.com', customReturnPath: 'outbound' });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->domains->create([
    'name' => 'example.com',
    'custom_return_path' => 'outbound'
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Domains.CreateParams = {
    "name": "example.com",
    "custom_return_path": "outbound"
  }

  resend.Domains.create(params)
  ```

  ```ruby Ruby theme={null}
  Resend.api_key = ENV["RESEND_API_KEY"]

  params = {
    name: "example.com",
    custom_return_path: "outbound"
  }
  domain = Resend::Domains.create(params)
  puts domain
  ```

  ```go Go theme={null}
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateDomainRequest{
      Name: "example.com",
      CustomReturnPath: "outbound",
  }

  domain, err := client.Domains.Create(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::CreateDomainOptions, Resend, Result};

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

    let _domain = resend
      .domains
      .add(CreateDomainOptions::new("example.com").with_custom_return_path("outbound"))
      .await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;

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

          CreateDomainOptions params = CreateDomainOptions
                  .builder()
                  .name("example.com")
                  .customReturnPath("outbound")
                  .build();

          CreateDomainResponse domain = resend.domains().create(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.DomainAddAsync( new DomainAddData {
     DomainName = "example.com",
     CustomReturnPath = "outbound"
  } );
  Console.WriteLine( "Domain Id={0}", resp.Content.Id );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/domains' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "example.com",
    "custom_return_path": "outbound"
  }'
  ```
</CodeGroup>

Custom return paths must adhere to the following rules:

* Must be 63 characters or less
* Must start with a letter, end with a letter or number, and contain only letters, numbers, and hyphens

Avoid setting values that could undermine credibility (e.g. `testing`), as they may be exposed to recipients in some email clients.

## What are DKIM records

DomainKeys Identified Mail (DKIM) is an email security standard designed to make sure that an email that claims to have come from a specific domain was indeed authorized by the owner of that domain.

The DKIM configuration is made of a TXT record that contains a public key that is used to verify the authenticity of the email.

<img alt="DKIM Records" />

## Understand a domain status

Domains can have different statuses, including:

* `not_started`: You've added a domain to Resend, but you haven't clicked on `Verify DNS Records` yet.
* `pending`: Resend is still trying to verify the domain.
* `verified`: Your domain is successfully verified for sending in Resend.
* `failed`: Resend was unable to detect the DNS records within 72 hours.
* `temporary_failure`: For a previously verified domain, Resend will periodically check for the DNS record required for verification. If at some point, Resend is unable to detect the record, the status would change to "Temporary Failure". Resend will recheck for the DNS record for 72 hours, and if it's unable to detect the record, the domain status would change to "Failure". If it's able to detect the record, the domain status would change to "Verified".

## Open and Click Tracking

Open and click tracking is disabled by default for all domains. You can enable it by clicking on the toggles within the domain settings.

<img alt="Open and Click Tracking" />

<Info>
  For best deliverability, we recommend disabling click and open tracking [for
  sensitive transactional
  emails](/dashboard/emails/deliverability-insights#disable-click-tracking).
</Info>

## How Open Tracking Works

A 1x1 pixel transparent GIF image is inserted in each email and includes a unique reference to this image file. When the image is downloaded, Resend can tell exactly which message was opened and by whom.

## How Click Tracking Works

To track clicks, Resend modifies each link in the body of the HTML email. When recipients open a link, they are sent to a Resend server, and are immediately redirected to the URL destination.

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

<Info>Currently, exports are limited to admin users of your team.</Info>

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

<Note>
  All exports your team creates are listed in the
  [Exports](https://resend.com/exports) page under **Settings** > **Team** >
  **Exports**. Select any export to view its details page. All members of your
  team can view your exports, but only admins can download the data.
</Note>


# Choosing a Region
Source: https://resend.com/docs/dashboard/domains/regions

Resend offers sending from multiple regions

Resend users have the option to send transactional and marketing emails from four different regions:

* North Virginia (us-east-1)
* Ireland (eu-west-1)
* São Paulo (sa-east-1)
* Tokyo (ap-northeast-1)

No matter where your users are, you can ensure that they receive your emails in a timely and efficient manner. You can visualize the different regions in the Resend dashboard:

<img alt="Multi Region Domains" />

## Why is this important?

Especially for transactional emails like magic links, password resets, and welcome messages, users expect to receive them right away. If they don't, they might not be able to access your service right away, which could be a missed opportunity for your organization.

Here are some of the other benefits of using our multi-region email sending feature:

1. **Faster delivery:** By sending emails from the region closest to your user, you can reduce latency and ensure a faster time-to-inbox. This can be the difference between people using/buying your product or not.
2. **Easier account management:** Instead of having to maintain different accounts for each region, we're providing multi-region within the same account. That way, you aren't juggling different login credentials.
3. **Increased resilience:** In case of disruption in one region, our multi-region feature enables you to send emails from a backup domain in a separate region, guaranteeing maximum uptime.

## Get Started

To start using our multi-region email sending feature, go to **[Domains](https://resend.com/domains)**, then select the option to add a new domain.

Finally, select the region you want to send your emails.

## How to set up multi-region for the same domain

For advanced needs, you can set up multiple regions for the same domain. We recommend setting a unique subdomain for each region (e.g., us.domain.com, eu.domain.com). When sending transactional emails or marketing emails, choose the right domain for your users.

## Changing Domain Region

If you'd like to switch the region your domain is currently set to:

1. Delete your current domain in the [Domain's page](https://resend.com/domains).
2. Add the same domain again, selecting the new region.
3. Update your DNS records to point to the new domain.

For more help, please reach out to [Support](https://resend.com/help), and we can help you out.


# Add an unsubscribe link to transactional emails
Source: https://resend.com/docs/dashboard/emails/add-unsubscribe-to-transactional-emails

Learn how to give email recipients the ability to unsubscribe without searching for the unsubscribe link.

<Info>
  For contact and unsubscribe management workflows, see the [Audiences
  overview](/dashboard/audiences/introduction), where Broadcasts are built for
  keeping track of topics, segments, and unsubscribe preferences.
</Info>

Resend doesn't manage contact lists for transactional emails.

If you manage your own list, you can add the `List-Unsubscribe: https://example.com/unsubscribe` header when sending emails using the Resend API.

As of February 2024, your bulk messages must include a URL version in your list-unsubscribe header, `List-Unsubscribe-Post: List-Unsubscribe=One-Click`, and to allow for a `POST` request from the same URL.

When receiving a `POST`, it should return a blank page with `200 (OK)` or `202 (Accepted)`, and should show the regular unsubscribe page with the `GET` method. Ensure that users stop receiving email within 48 hours of this request.

This header allows email clients to offer an easy “Unsubscribe” option in their UI, enhancing user experience and decreasing spam complaints.

You can read more about this requirement in our [Bulk Sending Requirements blog post.](https://resend.com/blog/gmail-and-yahoo-bulk-sending-requirements-for-2024#one-click-unsubscribe)

```ts Node.js {11} theme={null}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: 'hello world',
  text: 'it works!',
  headers: {
    'List-Unsubscribe': '<https://example.com/unsubscribe>',
  },
});
```

## Example

<Card title="Unsubscribe url header" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-unsubscribe-url-header">
  See the full source code.
</Card>


# Attachments
Source: https://resend.com/docs/dashboard/emails/attachments

Send emails with attachments.

There are two ways to send attachments:

1. [From a remote file](#send-attachments-from-a-remote-file)
2. [From a local file](#send-attachments-from-a-local-file)

<Info>
  We currently do not support sending attachments [when using our batch
  endpoint](/api-reference/emails/send-batch-emails).
</Info>

## Send attachments from a remote file

Include the `path` parameter to send attachments from a remote file. This parameter accepts a URL to the file you want to attach.

Define the file name that will be attached using the `filename` parameter.

<CodeGroup>
  ```ts Node.js {12-13} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Receipt for your payment',
    html: '<p>Thanks for the payment</p>',
    attachments: [
      {
        path: 'https://resend.com/static/sample/invoice.pdf',
        filename: 'invoice.pdf',
      },
    ],
  });
  ```

  ```php PHP {10-11} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'Receipt for your payment',
    'html' => '<p>Thanks for the payment</p>',
    'attachments' => [
      [
        'path' => 'https://resend.com/static/sample/invoice.pdf',
        'filename' => 'invoice.pdf'
      ]
    ]
  ]);
  ```

  ```python Python {6-7} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  attachment: resend.RemoteAttachment = {
    "path": "https://resend.com/static/sample/invoice.pdf",
    "filename": "invoice.pdf",
  }

  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Receipt for your payment",
    "html": "<p>Thanks for the payment</p>",
    "attachments": [attachment],
  }

  resend.Emails.send(params)
  ```

  ```rb Ruby {12-13} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Receipt for your payment",
    "html": "<p>Thanks for the payment</p>",
    "attachments": [
      {
        "path": "https://resend.com/static/sample/invoice.pdf",
        "filename": 'invoice.pdf',
      }
    ]
  }

  Resend::Emails.send(params)
  ```

  ```go Go {12-13} theme={null}
  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:        "Acme <onboarding@resend.dev>",
        To:          []string{"delivered@resend.dev"},
        Subject:     "Receipt for your payment",
        Html:        "<p>Thanks for the payment</p>",
        Attachments: []*resend.Attachment{attachment},
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust {12-13} theme={null}
  use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "Receipt for your payment";

    let path = "https://resend.com/static/sample/invoice.pdf";
    let filename = "invoice.pdf";

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>Thanks for the payment</p>")
      .with_attachment(CreateAttachment::from_path(path).with_filename(filename));

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {8-9} theme={null}
  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("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("Receipt for your payment")
                  .html("<p>Thanks for the payment</p>")
                  .attachments(att)
                  .build();

          CreateEmailResponse data = resend.emails().send(params);
      }
  }
  ```

  ```csharp .NET {14-18} theme={null}
  using Resend;
  using System.Collections.Generic;

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

  var message = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "Receipt for your payment",
      HtmlBody = "<p>Thanks for the payment</p>",
  };

  message.Attachments = new List<EmailAttachment>();
  message.Attachments.Add( new EmailAttachment() {
    Filename = "invoice.pdf",
    Path = "https://resend.com/static/sample/invoice.pdf",
  } );

  var resp = await resend.EmailSendAsync( message );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {11-12} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Receipt for your payment",
    "html": "<p>Thanks for the payment</p>",
    "attachments": [
      {
        "path": "https://resend.com/static/sample/invoice.pdf",
        "filename": "invoice.pdf"
      }
    ]
  }'
  ```
</CodeGroup>

## Send attachments from a local file

Include the `content` parameter to send attachments from a local file. This parameter accepts the Base64 encoded content of the file you want to attach.

Define the file name that will be attached using the `filename` parameter.

<CodeGroup>
  ```ts Node.js {16-17} theme={null}
  import { Resend } from 'resend';
  import fs from 'fs';

  const resend = new Resend('re_xxxxxxxxx');

  const filepath = `${__dirname}/static/invoice.pdf`;
  const attachment = fs.readFileSync(filepath).toString('base64');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Receipt for your payment',
    text: '<p>Thanks for the payment</p>',
    attachments: [
      {
        content: attachment,
        filename: 'invoice.pdf',
      },
    ],
  });
  ```

  ```php PHP {10-11} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'Receipt for your payment',
    'html' => '<p>Thanks for the payment</p>',
    'attachments' => [
      [
        'filename' => 'invoice.pdf',
        'content' => $invoiceBuffer
      ]
    ]
  ]);
  ```

  ```python Python {10} theme={null}
  import os
  import resend

  resend.api_key = "re_xxxxxxxxx"

  f: bytes = open(
    os.path.join(os.path.dirname(__file__), "../static/invoice.pdf"), "rb"
  ).read()

  attachment: resend.Attachment = {"content": list(f), "filename": "invoice.pdf"}

  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Receipt for your payment",
    "html": "<p>Thanks for the payment</p>",
    "attachments": [attachment],
  }

  resend.Emails.send(params)
  ```

  ```rb Ruby {14-15} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  file = IO.read("invoice.pdf")

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Receipt for your payment",
    "html": "<p>Thanks for the payment</p>",
    "attachments": [
      {
        "content": file.bytes,
        "filename": 'invoice.pdf',
      }
    ]
  }

  Resend::Emails.send(params)
  ```

  ```go Go {19-20} theme={null}
  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:        "Acme <onboarding@resend.dev>",
        To:          []string{"delivered@resend.dev"},
        Subject:     "Receipt for your payment",
        Html:        "<p>Thanks for the payment</p>",
        Attachments: []*resend.Attachment{attachment},
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust {22} theme={null}
  use std::fs::File;
  use std::io::Read;

  use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "Receipt for your payment";

    let filename = "invoice.pdf";
    let mut f = File::open(filename).unwrap();
    let mut invoice = Vec::new();
    f.read_to_end(&mut invoice).unwrap();

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>Thanks for the payment</p>")
      .with_attachment(CreateAttachment::from_content(invoice).with_filename(filename));

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {8-9} theme={null}
  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("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("Receipt for your payment")
                  .html("<p>Thanks for the payment</p>")
                  .attachments(att)
                  .build();

          CreateEmailOptions params = CreateEmailOptions.builder()
      }
  }
  ```

  ```csharp .NET {15-19} theme={null}
  using Resend;
  using System.Collections.Generic;
  using System.IO;

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

  var message = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "Receipt for your payment",
      HtmlBody = "<p>Thanks for the payment</p>",
  };

  message.Attachments = new List<EmailAttachment>();
  message.Attachments.Add( new EmailAttachment() {
    Filename = "invoice.pdf",
    Content = await File.ReadAllBytesAsync( "invoice.pdf" ),
  } );

  var resp = await resend.EmailSendAsync( message );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {11-12} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Receipt for your payment",
    "html": "<p>Thanks for the payment</p>",
    "attachments": [
      {
        "content": "UmVzZW5kIGF0dGFjaG1lbnQgZXhhbXBsZS4gTmljZSBqb2Igc2VuZGluZyB0aGUgZW1haWwh%",
        "filename": "invoice.txt"
      }
    ]
  }'
  ```
</CodeGroup>

## Embed Images using CID

You can optionally embed an image in the HTML body of the email. Both remote and local attachments are supported. All attachment requirements, options, and limitations apply to embedded inline images as well.

Embedding images requires two steps:

**1. Add the CID in the email HTML.**

Use the prefix `cid:` to reference the ID in the `src` attribute of an image tag in the HTML body of the email.

```html theme={null}
<img src="cid:logo-image" />
```

**2. Reference the CID in the attachment**

The content id is an arbitrary string set by you, and must be less than 128 characters.

<CodeGroup>
  ```ts Node.js {9, 14} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Thank you for contacting us',
    html: '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
    attachments: [
      {
        path: 'https://resend.com/static/sample/logo.png',
        filename: 'logo.png',
        contentId: 'logo-image',
      },
    ],
  });
  ```

  ```php PHP {7,12} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'Thank you for contacting us',
    'html' => '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
    'attachments' => [
      [
        'path' => 'https://resend.com/static/sample/logo.png',
        'filename' => 'logo.png',
        'content_id' => 'logo-image',
      ]
    ]
  ]);
  ```

  ```python Python {8,15} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  attachment: resend.RemoteAttachment = {
    "path": "https://resend.com/static/sample/logo.png",
    "filename": "logo.png",
    "content_id": "logo-image",
  }

  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Thank you for contacting us",
    "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
    "attachments": [attachment],
  }

  resend.Emails.send(params)
  ```

  ```rb Ruby {9, 14} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Thank you for contacting us",
    "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
    "attachments": [
      {
        "path": "https://resend.com/static/sample/logo.png",
        "filename": 'logo.png',
        "content_id": "logo-image",
      }
    ]
  }

  Resend::Emails.send(params)
  ```

  ```go Go {14, 21} theme={null}
  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/logo.png",
      Filename: "logo.png",
      ContentId: "logo-image",
    }

    params := &resend.SendEmailRequest{
        From:        "Acme <onboarding@resend.dev>",
        To:          []string{"delivered@resend.dev"},
        Subject:     "Thank you for contacting us",
        Html:        "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
        Attachments: []*resend.Attachment{attachment},
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust {14, 17} theme={null}
  use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "Thank you for contacting us";

    let path = "https://resend.com/static/sample/logo.png";
    let filename = "logo.png";
    let content_id = "logo-image";

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
      .with_attachment(
        CreateAttachment::from_path(path)
          .with_filename(filename)
          .with_content_id(content_id),
      );

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {10, 17} theme={null}
  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/logo.png")
                  .fileName("logo.png")
                  .ContentId("logo-image")
                  .build();

          CreateEmailOptions params = CreateEmailOptions.builder()
                  .from("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("Thank you for contacting us")
                  .html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
                  .attachments(att)
                  .build();

          CreateEmailResponse data = resend.emails().send(params);
      }
  }
  ```

  ```csharp .NET {11, 18} theme={null}
  using Resend;
  using System.Collections.Generic;

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

  var message = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "Thank you for contacting us",
      HtmlBody = "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  };

  message.Attachments = new List<EmailAttachment>();
  message.Attachments.Add( new EmailAttachment() {
    Filename = "logo.png",
    Path = "https://resend.com/static/sample/logo.png",
    ContentId = "logo-image",
  } );

  var resp = await resend.EmailSendAsync( message );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {8,13} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Thank you for contacting us",
    "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
    "attachments": [
      {
        "path": "https://resend.com/static/sample/logo.png",
        "filename": "logo.png",
        "content_id": "logo-image"
      }
    ]
  }'
  ```
</CodeGroup>

Learn more about [embedding images](/dashboard/emails/embed-inline-images).

## View and Download Attachments

You can view and download attachments when viewing a sent email that includes them.

To view and download attachments:

1. Go to [Emails](https://resend.com/emails).
2. Navigate to any email you sent with an attachment.
3. Click on the attachment to download it locally.

Attachments include the filename and an icon to help you identify the type of attachment. We show unique icons for each attachment type:

* Image
* PDF
* Spreadsheet
* Default (for unknown types)

## Attachment Limitations

* Emails can be no larger than 40MB (including attachments after Base64 encoding).
* Not all file types are supported. See the list of [unsupported file types](/knowledge-base/what-attachment-types-are-not-supported).
* Emails with attachments cannot be sent using our [batching endpoint](/api-reference/emails/send-batch-emails).

## Examples

<CardGroup>
  <Card title="Attachments with Next.js (remote file)" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-attachments">
    See the full source code.
  </Card>

  <Card title="Attachments with Next.js (local file)" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-attachments-content">
    See the full source code.
  </Card>
</CardGroup>


# Batch Sending
Source: https://resend.com/docs/dashboard/emails/batch-sending

Send up to 100 emails in a single API call.

Batch sending allows you to send multiple emails at once (up to 100) instead of making individual API requests for each email.

## When to use batch sending

Use batch sending when you need to:

* Send multiple transactional emails (e.g., order confirmations, notifications, etc.)
* Trigger emails to different recipients with unique content
* Reduce the number of API calls to improve performance

<Note>
  For marketing campaigns, [use our no-code editor,
  Broadcasts](/dashboard/broadcasts/introduction), instead.
</Note>

## Send batch emails

You can send up to 100 emails in a single API call using the batch endpoint. Each email in the batch can have different recipients, subjects, and content.

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.batch.send([
    {
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Welcome to Acme',
      html: '<p>Thanks for signing up!</p>',
    },
    {
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Order Confirmation',
      html: '<p>Your order has been confirmed.</p>',
    },
  ]);

  console.log(data);
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->batch->send([
    [
      'from' => 'Acme <onboarding@resend.dev>',
      'to' => ['delivered@resend.dev'],
      'subject' => 'Welcome to Acme',
      'html' => '<p>Thanks for signing up!</p>',
    ],
    [
      'from' => 'Acme <onboarding@resend.dev>',
      'to' => ['delivered@resend.dev'],
      'subject' => 'Order Confirmation',
      'html' => '<p>Your order has been confirmed.</p>',
    ]
  ]);
  ```

  ```py Python theme={null}
  import resend
  from typing import List

  resend.api_key = "re_xxxxxxxxx"

  params: List[resend.Emails.SendParams] = [
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Welcome to Acme",
      "html": "<p>Thanks for signing up!</p>",
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Order Confirmation",
      "html": "<p>Your order has been confirmed.</p>",
    }
  ]

  resend.Batch.send(params)
  ```

  ```rb Ruby theme={null}
  require "resend"

  Resend.api_key = 're_xxxxxxxxx'

  params = [
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Welcome to Acme",
      "html": "<p>Thanks for signing up!</p>",
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Order Confirmation",
      "html": "<p>Your order has been confirmed.</p>",
    }
  ]

  Resend::Batch.send(params)
  ```

  ```go Go theme={null}
  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:    "Acme <onboarding@resend.dev>",
        To:      []string{"delivered@resend.dev"},
        Subject: "Welcome to Acme",
        Html:    "<p>Thanks for signing up!</p>",
      },
      {
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"delivered@resend.dev"},
        Subject: "Order Confirmation",
        Html:    "<p>Your order has been confirmed.</p>",
      },
    }

    sent, err := client.Batch.SendWithContext(ctx, batchEmails)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Data)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::types::CreateEmailBaseOptions;
  use resend_rs::{Resend, Result};

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

    let emails = vec![
      CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        vec!["delivered@resend.dev"],
        "Welcome to Acme",
      )
      .with_html("<p>Thanks for signing up!</p>"),
      CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        vec!["delivered@resend.dev"],
        "Order Confirmation",
      )
      .with_html("<p>Your order has been confirmed.</p>"),
    ];

    let _emails = resend.batch.send(emails).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  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("Acme <onboarding@resend.dev>")
              .to("delivered@resend.dev")
              .subject("Welcome to Acme")
              .html("<p>Thanks for signing up!</p>")
              .build();

          CreateEmailOptions secondEmail = CreateEmailOptions.builder()
              .from("Acme <onboarding@resend.dev>")
              .to("delivered@resend.dev")
              .subject("Order Confirmation")
              .html("<p>Your order has been confirmed.</p>")
              .build();

          CreateBatchEmailsResponse data = resend.batch().send(
              Arrays.asList(firstEmail, secondEmail)
          );
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var mail1 = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "Welcome to Acme",
      HtmlBody = "<p>Thanks for signing up!</p>",
  };

  var mail2 = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "Order Confirmation",
      HtmlBody = "<p>Your order has been confirmed.</p>",
  };

  var resp = await resend.EmailBatchAsync([mail1, mail2]);
  Console.WriteLine("Nr Emails={0}", resp.Content.Data.Count);
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/emails/batch' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'[
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Welcome to Acme",
      "html": "<p>Thanks for signing up!</p>"
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Order Confirmation",
      "html": "<p>Your order has been confirmed.</p>"
    }
  ]'
  ```
</CodeGroup>

## Response format

The batch endpoint returns an array of email IDs for successfully created emails.

```json theme={null}
{
  "data": [
    {
      "id": "ae2014de-c168-4c61-8267-70d2662a1ce1"
    },
    {
      "id": "faccb7a5-8a28-4e9a-ac64-8da1cc3bc1cb"
    }
  ]
}
```

If the request fails, the response will include an `error` object with a `message` property. You can find more information about the error in the [Errors](/api-reference/errors) section of the API Reference.

## Limitations

When using batch sending, keep in mind:

* Maximum of **100 emails** per batch request
* The `attachments` field is not supported yet
* The `scheduled_at` field is not supported yet
* Each email in the batch is processed independently
* The request will fail and return an error if any email in your payload is invalid (e.g., required fields are missing, fields contain invalid data, etc.).

## View batch emails

All emails sent via the batch endpoint appear in the [Emails](https://resend.com/emails) page of your dashboard, just like individually sent emails. Each email will have a `queued` status initially before being processed.

## API Reference

For complete API documentation, see the [Send Batch Emails API reference](/api-reference/emails/send-batch-emails).


# Custom Headers
Source: https://resend.com/docs/dashboard/emails/custom-headers

Customize how emails are sent with your own headers.

Email headers are typically hidden from the end user but are crucial for deliverability. They include information about the sender, receiver, timestamp, and more.

Resend already includes all the necessary headers for you, but now you can also add your own custom headers.

This is a fairly advanced feature, but it can be useful for a few things:

* Prevent threading on Gmail with the **`X-Entity-Ref-ID`** header ([Example](https://github.com/resend/resend-examples/tree/main/with-prevent-thread-on-gmail))
* Include a shortcut for users to unsubscribe with the **`List-Unsubscribe`** header ([Example](https://github.com/resend/resend-examples/tree/main/with-unsubscribe-url-header))

Here's how you can add custom headers to your emails:

<CodeGroup>
  ```ts Node.js {11} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<p>it works!</p>',
    headers: {
      'X-Entity-Ref-ID': 'xxx_xxxx',
    },
  });
  ```

  ```php PHP {9} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'hello world',
    'html' => '<p>it works!</p>',
    'headers' => [
      'X-Entity-Ref-ID' => 'xxx_xxxx',
    ]
  ]);
  ```

  ```python Python {11} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Emails.SendParams = {
    "from": "onboarding@resend.dev",
    "to": ["delivered@resend.dev"],
    "subject": "hi",
    "html": "<p>it works!</p>",
    "headers": {
      "X-Entity-Ref-ID": "xxx_xxxx"
    }
  }

  email = resend.Emails.send(params)
  print(email)
  ```

  ```rb Ruby {11} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "headers": {
      "X-Entity-Ref-ID": "123"
    },
  }

  sent = Resend::Emails.send(params)
  puts sent
  ```

  ```go Go {17} theme={null}
  import (
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

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

    params := &resend.SendEmailRequest{
        From:        "Acme <onboarding@resend.dev>",
        To:          []string{"delivered@resend.dev"},
        Subject:     "hello world",
        Html:        "<p>it works!</p>",
        Headers:     map[string]string{
          "X-Entity-Ref-ID": "xxx_xxxx",
        }
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust {14} theme={null}
  use resend_rs::types::{Attachment, CreateEmailBaseOptions, Tag};
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "hello world";

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>it works!</p>")
      .with_header("X-Entity-Ref-ID", "xxx_xxxx");

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {13} theme={null}
  import com.resend.*;

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

          CreateEmailOptions params = CreateEmailOptions.builder()
                  .from("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("hello world")
                  .html("<p>it works!</p>")
                  .headers(Map.of(
                      "X-Entity-Ref-ID", "xxx_xxxx"
                  ))
                  .build();

          CreateEmailResponse data = resend.emails().send(params);
      }
  }
  ```

  ```csharp .NET {12-15} theme={null}
  using Resend;
  using System.Collections.Generic;

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

  var message = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
      Headers = new Dictionary<string, string>()
      {
          { "X-Entity-Ref-ID", "xxx_xxxx" },
      },
  };

  var resp = await resend.EmailSendAsync( message );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {10} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "headers": {
      "X-Entity-Ref-ID": "xxx_xxxx"
    }
  }'
  ```
</CodeGroup>


# Deliverability Insights
Source: https://resend.com/docs/dashboard/emails/deliverability-insights

Improve your deliverability with tailored insights based on your sending.

When you view your email within Resend, there is a "Insights" option. When selected, this will run eight deliverability best practice checks on your email and recommend possible changes to improve deliverability.

<img alt="Deliverability Insights" />

If a check passes, you'll get a nice green check. Resend will provide advice if it fails. We break these into two categories: Attention and Improvements.

## Attention Insights

Changes to your email that can improve deliverability.

<img alt="Attention Insights" />

#### Link URLs match sending domain

Ensure that the URLs in your email match the sending domain. Mismatched URLs can trigger spam filters.

For example, if your sending domain is `@widgets.com`, ensure links within the message point back to `https://widgets.com`.

#### DMARC Record is Valid

DMARC is a TXT record published in the DNS that specifies how email receivers should handle messages from your domain that don’t pass SPF or DKIM validation. [A valid DMARC record](/dashboard/domains/dmarc) can help improve email deliverability.

Starting in 2024, Gmail and Yahoo require senders to have a DMARC record published. When [viewing your domain](https://resend.com/domains) in Resend, we provide a suggested DMARC record if you’re unsure what to publish.

#### Include Plain Text Version

Including a plain text version of your email ensures that your message is accessible to all recipients, including those who have email clients that do not support HTML.

If you're using Resend's API, [plain text is passed via the `text` parameter](https://resend.com/docs/api-reference/emails/send-email).

This can also generate plain text using [React Email](https://react.email/docs/utilities/render#4-convert-to-plain-text).

#### Don't use "no-reply"

Indicating that this is a one-way communication decreases trust. Some email providers use engagement (email replies) when deciding how to filter your email. A valid email address allows you to communicate with your recipients easily if they have questions.

#### Keep email body size small

Gmail limits the size of each email message to 102 KB. Once that limit is reached, the remaining content is clipped and hidden behind a link to view the entire message. Keep your email body size small to avoid this issue.

This check will show the current size of your email.

## Improvement Insights

If you're diagnosing a deliverability issue, changing your email practices could be helpful.

<img alt="Improvement Insights" />

#### Use a Subdomain

Using a subdomain instead of the root domain helps segment your sending by purpose. This protects different types of sending from impacting the reputation of others and clearly shows the sending purpose.

#### Disable Click Tracking

Click tracking modifies links, sometimes causing spam filters to flag emails as suspicious or phishing attempts. Disabling click tracking can help with email deliverability, especially for sensitive transactional emails like login or email verification.

If on, you can [disable click tracking on your domain in Resend](https://resend.com/domains).

#### Disable Open Tracking

Spam filters are sensitive to tracking pixels, flagging them as potential spam. Without these tracking elements, emails may bypass these filters more effectively, especially for sensitive transactional emails like login or email verification.

If on, you can [disable open tracking on your domain in Resend](https://resend.com/domains).


# Email Bounces
Source: https://resend.com/docs/dashboard/emails/email-bounces

Understanding and resolving delivery issues.

## Why does an email bounce?

A bounce happens when an email cannot be delivered to the person it was meant for, and is returned to the sender. It essentially "bounces" back to the person who sent it.

Some reasons include invalid email addresses, full mailboxes, technical issues with email servers, spam filters, message size restrictions, or blacklisting of the sender's email server.

## Bounce Types and Subtypes

When an email bounces, Resend receives a message from the recipient's mail server. The bounce message explains why the delivery failed so the sender can fix the issue.

There are three types of bounces:

1. `Permanent` - also known as "hard bounce,” where the recipient's mail server rejects the email and will never be delivered.

   * `General` - The recipient's email provider sent a hard bounce message.
   * `NoEmail` - It was not possible to retrieve the recipient email address from the bounce message.

2. `Transient` - also known as "soft bounce,” where the recipient's mail server rejects the email but it could be delivered in the future.
   * `General` - The recipient's email provider sent a general bounce message. You might be able to send a message to the same recipient in the future if the issue that caused the message to bounce is resolved.
   * `MailboxFull` - The recipient's email provider sent a bounce message because the recipient's inbox was full. You might be able to send to the same recipient in the future when the mailbox is no longer full.
   * `MessageTooLarge` - The recipient's email provider sent a bounce message because message you sent was too large. You might be able to send a message to the same recipient if you reduce the size of the message.
   * `ContentRejected` - The recipient's email provider sent a bounce message because the message you sent contains content that the provider doesn't allow. You might be able to send a message to the same recipient if you change the content of the message.
   * `AttachmentRejected` - The recipient's email provider sent a bounce message because the message contained an unacceptable attachment. For example, some email providers may reject messages with attachments of a certain file type, or messages with very large attachments. You might be able to send a message to the same recipient if you remove or change the content of the attachment.

<Tip>
  Sometimes, inboxes use autoresponders to signal a bounce. A `transient` status
  could mean it's related to the autoresponder, and it's not a permanent issue.
</Tip>

3. `Undetermined` - where the recipient's email server bounced, but the bounce message didn't contain enough information for Resend to determine the underlying reason.
   * `Undetermined` - The recipient's email provider sent a bounce message. The bounce message didn't contain enough information for Resend to determine the reason for the bounce.

## Viewing Bounce Details in Resend

You can see the bounce details by clicking on the email, and hovering over the `Bounced` label.

<img alt="Email Bounce Notification" />

Once you click **See Details**, the drawer will open on the right side of your screen with the bounce type, subtype, along with suggestions on how to proceed.

If the email is on the suppression list, you can click **Remove from Suppression List** to remove it.

<img alt="Email Bounce Drawer" />


# Email Suppressions
Source: https://resend.com/docs/dashboard/emails/email-suppressions

Understanding and resolving delivery issues.

## What does it mean that the email was `suppressed`?

A suppression happens when you try sending an email to a recipient that previously [bounced](/dashboard/emails/email-bounces) or marked your email as spam.

To protect your sender reputation and our sending infrastructure, we proactively stop that delivery from happening.

## What caused the suppression?

The suppression is caused by:

* `Bounced` when the recipient's mail server rejects the email and the response indicates a permanent failure to deliver. There could be [multiple reasons why an email `bounced`](/dashboard/emails/email-bounces#bounce-types-and-subtypes).
* `Complained` when the recipient marked your email as spam.

<Tip>
  Not all Inbox Service Providers return a `complained` event. Most notably,
  Gmail/Google Workspace doesn't.
</Tip>

## Viewing Suppression Details in Resend

You can see the suppressed details by clicking on the email, and hovering over the `Suppressed` label.

<img alt="Email Suppression Notification" />

Once you click **See Details**, the drawer will open on the right side of your screen with the suppression reason along with suggestions on how to proceed.

You can also click **Remove from Suppression List** to prevent the address from being suppressed. Do note that if it bounces or is marked as spam again, it'll be suppressed again. Multiple or repeated bounces will negatively impact your sender reputation.


# Embed Inline Images
Source: https://resend.com/docs/dashboard/emails/embed-inline-images

Send emails with inline images.

You can optionally embed an image in the HTML body of the email. This allows you to include images without needing to host them in an external server.

<Info>
  We currently do not support sending attachments (including inline images)
  [when using our batch endpoint](/api-reference/emails/send-batch-emails).
</Info>

<Steps>
  <Step title="Add the CID in the email HTML.">
    Use the prefix `cid:` to reference the ID in the `src` attribute of an image tag in the HTML body of the email.

    ```html theme={null}
      <img src="cid:logo-image">
    ```
  </Step>

  <Step title="Reference the CID in the attachment.">
    Include the content id parameter in the attachment object (see below for example implementations). The ID is an arbitrary string set by you, and must be less than 128 characters.
  </Step>
</Steps>

## Implementation details

Both remote and local attachments are supported. All attachment [requirements, options, and limitations](/dashboard/emails/attachments) apply to inline images as well.

As with all our features, inline images are available across all our SDKs.

### Remote image example

<CodeGroup>
  ```ts Node.js {9, 14} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Thank you for contacting us',
    html: '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
    attachments: [
      {
        path: 'https://resend.com/static/sample/logo.png',
        filename: 'logo.png',
        contentId: 'logo-image',
      },
    ],
  });
  ```

  ```php PHP {7,12} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'Thank you for contacting us',
    'html' => '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
    'attachments' => [
      [
        'path' => 'https://resend.com/static/sample/logo.png',
        'filename' => 'logo.png',
        'content_id' => 'logo-image',
      ]
    ]
  ]);
  ```

  ```python Python {8,15} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  attachment: resend.RemoteAttachment = {
    "path": "https://resend.com/static/sample/logo.png",
    "filename": "logo.png",
    "content_id": "logo-image",
  }

  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Thank you for contacting us",
    "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
    "attachments": [attachment],
  }

  resend.Emails.send(params)
  ```

  ```rb Ruby {9, 14} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Thank you for contacting us",
    "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
    "attachments": [
      {
        "path": "https://resend.com/static/sample/logo.png",
        "filename": 'logo.png',
        "content_id": "logo-image",
      }
    ]
  }

  Resend::Emails.send(params)
  ```

  ```go Go {14, 21} theme={null}
  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/logo.png",
      Filename: "logo.png",
      ContentId: "logo-image",
    }

    params := &resend.SendEmailRequest{
        From:        "Acme <onboarding@resend.dev>",
        To:          []string{"delivered@resend.dev"},
        Subject:     "Thank you for contacting us",
        Html:        "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
        Attachments: []*resend.Attachment{attachment},
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust {14, 17} theme={null}
  use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "Thank you for contacting us";

    let path = "https://resend.com/static/sample/logo.png";
    let filename = "logo.png";
    let content_id = "logo-image";

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
      .with_attachment(
        CreateAttachment::from_path(path)
          .with_filename(filename)
          .with_content_id(content_id),
      );

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {10, 17} theme={null}
  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/logo.png")
                  .fileName("logo.png")
                  .ContentId("logo-image")
                  .build();

          CreateEmailOptions params = CreateEmailOptions.builder()
                  .from("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("Thank you for contacting us")
                  .html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
                  .attachments(att)
                  .build();

          CreateEmailResponse data = resend.emails().send(params);
      }
  }
  ```

  ```csharp .NET {11, 18} theme={null}
  using Resend;
  using System.Collections.Generic;

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

  var message = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "Thank you for contacting us",
      HtmlBody = "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  };

  message.Attachments = new List<EmailAttachment>();
  message.Attachments.Add( new EmailAttachment() {
    Filename = "logo.png",
    Path = "https://resend.com/static/sample/logo.png",
    ContentId = "logo-image",
  } );

  var resp = await resend.EmailSendAsync( message );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {8,13} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Thank you for contacting us",
    "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
    "attachments": [
      {
        "path": "https://resend.com/static/sample/logo.png",
        "filename": "logo.png",
        "content_id": "logo-image"
      }
    ]
  }'
  ```
</CodeGroup>

### Local image example

<CodeGroup>
  ```ts Node.js {13, 18} theme={null}
  import { Resend } from 'resend';
  import fs from 'fs';

  const resend = new Resend('re_xxxxxxxxx');

  const filepath = `${__dirname}/static/logo.png`;
  const attachment = fs.readFileSync(filepath).toString('base64');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Thank you for contacting us',
    text: '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
    attachments: [
      {
        content: attachment,
        filename: 'logo.png',
        contentId: 'logo-image',
      },
    ],
  });
  ```

  ```php PHP {7, 12} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'Thank you for contacting us',
    'html' => '<p>Here is our <img src="cid:logo-image"/> inline logo</p>',
    'attachments' => [
      [
        'filename' => 'logo.png',
        'content' => $invoiceBuffer,
        'content_id' => 'logo-image',
      ]
    ]
  ]);
  ```

  ```python Python {10, 16} theme={null}
  import os
  import resend

  resend.api_key = "re_xxxxxxxxx"

  f: bytes = open(
    os.path.join(os.path.dirname(__file__), "../static/logo.png"), "rb"
  ).read()

  attachment: resend.Attachment = {"content": list(f), "filename": "logo.png", "content_id": "logo-image"}

  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Thank you for contacting us",
    "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
    "attachments": [attachment],
  }

  resend.Emails.send(params)
  ```

  ```rb Ruby {11,16} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  file = IO.read("logo.png")

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Thank you for contacting us",
    "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
    "attachments": [
      {
        "content": file.bytes,
        "filename": 'logo.png',
        "content_id": "logo-image",
      }
    ]
  }

  Resend::Emails.send(params)
  ```

  ```go Go {21, 28} theme={null}
  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/logo.png")
    if err != nil {
      panic(err)
    }

    attachment := &resend.Attachment{
      Content:  f,
      Filename: "logo.png",
      ContentId: "logo-image",
    }

    params := &resend.SendEmailRequest{
        From:        "Acme <onboarding@resend.dev>",
        To:          []string{"delivered@resend.dev"},
        Subject:     "Thank you for contacting us",
        Html:        "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
        Attachments: []*resend.Attachment{attachment},
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust {16,22} theme={null}
  use std::fs::File;
  use std::io::Read;

  use resend_rs::types::{CreateAttachment, CreateEmailBaseOptions};
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "Thank you for contacting us";

    let filename = "logo.png";
    let content_id = "logo-image";
    let mut f = File::open(filename).unwrap();
    let mut invoice = Vec::new();
    f.read_to_end(&mut invoice).unwrap();

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
      .with_attachment(
        CreateAttachment::from_content(invoice)
          .with_filename(filename)
          .with_content_id(content_id),
      );

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {10, 17} theme={null}
  import com.resend.*;

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

          Attachment att = Attachment.builder()
                  .fileName("logo.png")
                  .content("invoiceBuffer")
                  .contentId("logo-image")
                  .build();

          CreateEmailOptions params = CreateEmailOptions.builder()
                  .from("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("Thank you for contacting us")
                  .html("<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>")
                  .attachments(att)
                  .build();

          CreateEmailOptions params = CreateEmailOptions.builder()
      }
  }
  ```

  ```csharp .NET {12, 19} theme={null}
  using Resend;
  using System.Collections.Generic;
  using System.IO;

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

  var message = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "Thank you for contacting us",
      HtmlBody = "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
  };

  message.Attachments = new List<EmailAttachment>();
  message.Attachments.Add( new EmailAttachment() {
    Filename = "logo.png",
    Content = await File.ReadAllBytesAsync( "logo.png" ),
    ContentId = "logo-image",
  } );

  var resp = await resend.EmailSendAsync( message );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {8, 13} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Thank you for contacting us",
    "html": "<p>Here is our <img src=\"cid:logo-image\"/> inline logo</p>",
    "attachments": [
      {
        "content": "UmVzZW5kIGF0dGFjaG1lbnQgZXhhbXBsZS4gTmljZSBqb2Igc2VuZGluZyB0aGUgZW1haWwh%",
        "filename": "invoice.txt",
        "content_id": "logo-image"
      }
    ]
  }'
  ```
</CodeGroup>

## Other considerations

Before adding inline images, consider the following.

* As these images are sent as attachments, you need to encode your image as Base64 when sending the raw content via the API. There is no need to do this when passing the path of a remote image (the API handles this for you).
* Inline images increase the size of the email.
* Inline images may be rejected by some clients (especially webmail).
* As with all attachments, we recommend adding a `content_type` (e.g. `image/png`) or `filename` (e.g. `logo.png`) parameter to the attachment object, as this often helps email clients render the attachment correctly.

<Note>
  All attachments (including inline images) do not currently display in the
  [emails dashboard](https://resend.com/emails) when previewing email HTML.
</Note>


# Idempotency Keys
Source: https://resend.com/docs/dashboard/emails/idempotency-keys

Use idempotency keys to ensure that emails are sent only once.

Include an idempotency key in any email requests to ensure that the same email request is processed only once, even if it's sent multiple times.

<Info>
  Idempotency keys are currently supported on the `POST /emails` and the `POST
      /emails/batch` endpoints on the Resend API.
</Info>

## How does it work?

When you send an email with an idempotency key, we check if an email with the same idempotency key has already been sent in the last 24 hours. **This is an optional feature** that simplifies managing retries on your side.

This makes it safe to retry requests that send an email. You don't have to worry about checking if the original request was sent -- you can just make the same request and our API will give the same response, without actually sending the email again.

## How to use idempotency keys?

Idempotency keys can be **up to 256 characters** and should be unique per API request.

We **recommend using a UUID** or other string that uniquely identifies that specific email.

<Tip>If you have multiple events that trigger emails related to a single entity in your system, you can format your idempotency keys to take advantage of that entity's ID. One idea is to format idempotency keys like `<event-type>/<entity-id>`, for example `welcome-user/123456789`. The specific format you use is up to you.</Tip>

Send the key in the `Idempotency-Key` HTTP header in your API requests. Our SDKs also provide a convenient way to set this header. If you're using SMTP, you can set the `Resend-Idempotency-Key` email header instead.

We keep idempotency keys in our system for **24 hours**. This should give you an ample window to retry any failed processes on your end without having to keep track of the sent status.

### `POST /emails` endpoint example

<CodeGroup>
  ```ts Node.js {9} theme={null}
  await resend.emails.send(
    {
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'hello world',
      html: '<p>it works!</p>',
    },
    {
      idempotencyKey: 'welcome-user/123456789',
    },
  );
  ```

  ```php PHP {9} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'hello world',
    'html' => '<p>it works!</p>',
  ], [
    'idempotency_key' => 'welcome-user/123456789',
  ]);
  ```

  ```python Python {9} theme={null}
  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>"
  }

  options: resend.Emails.SendOptions = {
    "idempotency_key": "welcome-user/123456789",
  }

  resend.Emails.send(params, options)
  ```

  ```rb Ruby {9} theme={null}
  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>"
  }
  Resend::Emails.send(
    params,
    options: { idempotency_key: "welcome-user/123456789" }
  )
  ```

  ```go Go {9} theme={null}
  ctx := context.TODO()
  params := &resend.SendEmailRequest{
    From:    "onboarding@resend.dev",
    To:      []string{"delivered@resend.dev"},
    Subject: "hello world",
    Html:    "<p>it works!</p>",
  }
  options := &resend.SendEmailOptions{
    IdempotencyKey: "welcome-user/123456789",
  }
  _, err := client.Emails.SendWithOptions(ctx, params, options)
  if err != nil {
    panic(err)
  }
  ```

  ```rust Rust {14} theme={null}
  use resend_rs::types::CreateEmailBaseOptions;
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "Hello World";

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>it works!</p>")
      .with_idempotency_key("welcome-user/123456789");

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {9} theme={null}
  CreateEmailOptions params = CreateEmailOptions.builder()
    .from("Acme <onboarding@resend.dev>")
    .to("delivered@resend.dev")
    .subject("hello world")
    .html("<p>it works!</p>")
    .build();

  RequestOptions options = RequestOptions.builder()
    .setIdempotencyKey("welcome-user/123456789").build();

  CreateEmailResponse data = resend.emails().send(params, options);
  ```

  ```csharp C# {11} theme={null}
  using Resend;

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

  var key = IdempotencyKey.New<int>( "welcome-user", 123456789 );
  var resp = await resend.EmailSendAsync(key, new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
  } );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {4} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -H 'Idempotency-Key: welcome-user/123456789' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>"
  }'
  ```

  ```yaml SMTP {4} theme={null}
  From: Acme <onboarding@resend.dev>
  To: delivered@resend.dev
  Subject: hello world
  Resend-Idempotency-Key: welcome-user/123456789

  <p>it works!</p>
  ```
</CodeGroup>

### `POST /emails/batch` endpoint example

<Tip>
  Format your idempotency keys to take advantage of that entity's ID (i.e.,
  `<event-type>/<entity-id>`). For batch sends, choose a key that represents the whole batch, like a team, workspace, or project (i.e., `team-quota/123456789`).
</Tip>

<CodeGroup>
  ```ts Node.js {21} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.batch.send(
    [
      {
        from: 'Acme <onboarding@resend.dev>',
        to: ['foo@gmail.com'],
        subject: 'hello world',
        html: '<h1>it works!</h1>',
      },
      {
        from: 'Acme <onboarding@resend.dev>',
        to: ['bar@outlook.com'],
        subject: 'world hello',
        html: '<p>it works!</p>',
      },
    ],
    {
      idempotencyKey: 'team-quota/123456789',
    },
  );
  ```

  ```php PHP {19} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->batch->send(
    [
      [
        'from' => 'Acme <onboarding@resend.dev>',
        'to' => ['foo@gmail.com'],
        'subject' => 'hello world',
        'html' => '<h1>it works!</h1>',
      ],
      [
        'from' => 'Acme <onboarding@resend.dev>',
        'to' => ['bar@outlook.com'],
        'subject' => 'world hello',
        'html' => '<p>it works!</p>',
      ]
    ],
    [
      'idempotency_key' => 'team-quota/123456789',
    ]
  );
  ```

  ```py Python {22} theme={null}
  import resend
  from typing import List

  resend.api_key = "re_xxxxxxxxx"

  params: List[resend.Emails.SendParams] = [
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["foo@gmail.com"],
      "subject": "hello world",
      "html": "<h1>it works!</h1>",
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["bar@outlook.com"],
      "subject": "world hello",
      "html": "<p>it works!</p>",
    }
  ]

  options: resend.Batch.SendOptions = {
    "idempotency_key": "team-quota/123456789",
  }

  resend.Batch.send(params, options)
  ```

  ```rb Ruby {22} theme={null}
  require "resend"

  Resend.api_key = 're_xxxxxxxxx'

  params = [
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["foo@gmail.com"],
      "subject": "hello world",
      "html": "<h1>it works!</h1>",
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["bar@outlook.com"],
      "subject": "world hello",
      "html": "<p>it works!</p>",
    }
  ]

  Resend::Batch.send(
    params,
    options: { idempotency_key: "team-quota/123456789" }
  )
  ```

  ```go Go {32} theme={null}
  package examples

  import (
  	"fmt"
  	"os"

  	"github.com/resend/resend-go/v3"
  )

  func main() {

    ctx := context.TODO()

    client := resend.NewClient("re_xxxxxxxxx")

    var batchEmails = []*resend.SendEmailRequest{
      {
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"foo@gmail.com"},
        Subject: "hello world",
        Html:    "<h1>it works!</h1>",
      },
      {
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"bar@outlook.com"},
        Subject: "world hello",
        Html:    "<p>it works!</p>",
      },
    }

    options := &resend.BatchSendEmailOptions{
      IdempotencyKey: "team-quota/123456789",
    }

    sent, err := client.Batch.SendWithOptions(ctx, batchEmails, options)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Data)
  }
  ```

  ```rust Rust {23} theme={null}
  use resend_rs::types::CreateEmailBaseOptions;
  use resend_rs::{Resend, Result};

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

    let emails = vec![
      CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        vec!["foo@gmail.com"],
        "hello world",
      )
      .with_html("<h1>it works!</h1>"),
      CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        vec!["bar@outlook.com"],
        "world hello",
      )
      .with_html("<p>it works!</p>"),
    ];

    let _emails = resend.batch.send_with_idempotency_key(emails, "team-quota/123456789").await?;

    Ok(())
  }
  ```

  ```java Java {23} theme={null}
  import com.resend.*;

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

          CreateEmailOptions firstEmail = CreateEmailOptions.builder()
              .from("Acme <onboarding@resend.dev>")
              .to("foo@gmail.com")
              .subject("hello world")
              .html("<h1>it works!</h1>")
              .build();

          CreateEmailOptions secondEmail = CreateEmailOptions.builder()
              .from("Acme <onboarding@resend.dev>")
              .to("bar@outlook.com")
              .subject("world hello")
              .html("<p>it works!</p>")
              .build();

          CreateBatchEmailsResponse data = resend.batch().send(
              Arrays.asList(firstEmail, secondEmail),
              Map.of("idempotency_key", "team-quota/123456789")
          );
      }
  }
  ```

  ```csharp .NET {5} theme={null}
  using Resend;

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

  var key = IdempotencyKey.New<int>( "team-quota", 123456789 );

  var mail1 = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "foo@gmail.com",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
  };

  var mail2 = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "bar@outlook.com",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
  };

  var resp = await resend.EmailBatchAsync(key, [ mail1, mail2 ] );
  Console.WriteLine( "Nr Emails={0}", resp.Content.Count );
  ```

  ```bash cURL {4} theme={null}
  curl -X POST 'https://api.resend.com/emails/batch' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -H 'Idempotency-Key: team-quota/123456789' \
       -d $'[
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["foo@gmail.com"],
      "subject": "hello world",
      "html": "<h1>it works!</h1>"
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["bar@outlook.com"],
      "subject": "world hello",
      "html": "<p>it works!</p>"
    }
  ]'
  ```
</CodeGroup>

## Possible responses

After checking if an email with the same idempotency key has already been sent, Resend returns one of the following responses:

* **Successful responses** will return the email ID of the sent email.
* **Error responses** will return one of the following errors:
  * `400`: `invalid_idempotency_key` - the idempotency key has to be between 1-256 characters. You can retry with a valid key or without supplying an idempotency key.
  * `409`: `invalid_idempotent_request` - this idempotency key has already been used on a request that had a different payload. Retrying this request is useless without changing the idempotency key or payload.
  * `409`: `concurrent_idempotent_requests` - another request with the same idempotency key is currently in progress. As it isn't finished yet, Resend can't return its original response, but it is safe to retry this request later if needed.


# Managing Emails
Source: https://resend.com/docs/dashboard/emails/introduction

Learn how to view and manage all sent emails on the Resend Dashboard.

## View email details

See all the metadata associated with an email, including the sender address, recipient address, subject, and more from the [Emails](https://resend.com/emails) page. Select any email to view its details.

<img alt="Email Details" />

Each email contains a **Preview**, **Plain Text**, and **HTML** version to visualize the content of your sent email in its various formats.

## Understand email events

Here are all the events that can be associated with an email:

* `bounced` - The recipient's mail server rejected the email. ([Learn more about bounced emails](/dashboard/emails/email-bounces))
* `canceled` - The scheduled email was canceled (by user).
* `clicked` - The recipient clicked on a link in the email.
* `complained` - The email was successfully delivered to the recipient's mail server, but the recipient marked it as spam.
* `delivered` - Resend successfully delivered the email to the recipient's mail server.
* `delivery_delayed` - The email couldn't be delivered to the recipient's mail server because a temporary issue occurred. Delivery delays can occur, for example, when the recipient's inbox is full, or when the receiving email server experiences a transient issue.
* `failed` - The email failed to be sent.
* `opened` - The recipient opened the email.
* `queued` - The email created from Broadcasts or Batches is queued for delivery.
* `scheduled` - The email is scheduled for delivery.
* `sent` - The email was sent successfully.
* `suppressed` - The email was not sent because the recipient is on the suppression list. ([Learn more about the suppression list](/knowledge-base/why-are-my-emails-landing-on-the-suppression-list))

## Share email link

You can share a public link of a sent email, which is valid for 48 hours. Anyone with the link can visualize the email.

To share a link, click on the **dropdown menu** <Icon icon="ellipsis" />, and select **Share email**.

<img alt="Email - Share Link Option" />

Then copy the URL and share it with your team members.

<img alt="Email - Share Link Modal" />

Anyone with the link can visualize the email without authenticating for 48 hours.

<img alt="Email - Share Link Item" />

## See associated logs

You can check all the logs associated with an email. This will help you troubleshoot any issues with the request itself.

To view the logs, click on the dropdown menu, and select "View log".

<img alt="Email - View Logs Option" />

This will take you to logs, where you can see all the logs associated with the email.

<img alt="Email - View Logs Item" />

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

<Info>Currently, exports are limited to admin users of your team.</Info>

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

<Note>
  All exports your team creates are listed in the
  [Exports](https://resend.com/exports) page under **Settings** > **Team** >
  **Exports**. Select any export to view its details page. All members of your
  team can view your exports, but only admins can download the data.
</Note>


# Schedule Email
Source: https://resend.com/docs/dashboard/emails/schedule-email

Send emails at a specific time without additional complexity.

While some emails need to be delivered as soon as possible, like password resets or magic links, others can be scheduled for a specific time.

Here are some examples of when you might want to schedule an email:

* Send welcome email **5 minutes after** signup
* Trigger a reminder email **24 hours before** an event
* Schedule a weekly digest email for the **next day at 9am PST**

Before, you had to use external services to handle the scheduling logic, but now you can use the new Resend API to schedule emails.

<Info>Emails can be scheduled up to 30 days in advance.</Info>

There are two ways to schedule an email:

1. [Using natural language](#1-schedule-using-natural-language)
2. [Using date format](#2-schedule-using-date-format)

## 1. Schedule using natural language

You can use the various Resend SDKs to schedule emails.

The date can be defined using natural language, such as `"in 1 hour"`, `"tomorrow at 9am"`, or `"Friday at 3pm ET"`.

<CodeGroup>
  ```ts Node.js {10} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<p>it works!</p>',
    scheduledAt: 'in 1 min',
  });
  ```

  ```php PHP {8} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'hello world',
    'html' => '<p>it works!</p>',
    'scheduled_at' => 'in 1 min'
  ]);
  ```

  ```python Python {10} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "scheduled_at": "in 1 min"
  }

  resend.Emails.send(params)
  ```

  ```rb Ruby {10} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "scheduled_at": "in 1 min"
  }

  Resend::Emails.send(params)
  ```

  ```go Go {16} theme={null}
  import (
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

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

    params := &resend.SendEmailRequest{
      From:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Subject:     "hello world",
      Html:        "<p>it works!</p>",
      ScheduledAt: "in 1 min"
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust {14} theme={null}
  use resend_rs::types::CreateEmailBaseOptions;
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "hello world";

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>it works!</p>")
      .with_scheduled_at("in 1 min");

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {12} theme={null}
  import com.resend.*;

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

          CreateEmailOptions params = CreateEmailOptions.builder()
                  .from("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("hello world")
                  .html("<p>it works!</p>")
                  .scheduledAt("in 1 min")
                  .build();

          CreateEmailResponse data = resend.emails().send(params);
      }
  }
  ```

  ```csharp .NET {11} theme={null}
  using Resend;

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

  var resp = await resend.EmailSendAsync( new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
      MomentSchedule = "in 1 min",
  } );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {9} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "scheduled_at": "in 1 min"
  }'
  ```
</CodeGroup>

## 2. Schedule using date format

You can also use a date in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format (e.g: `2024-08-05T11:52:01.858Z`).

<CodeGroup>
  ```ts Node.js {5} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const oneMinuteFromNow = new Date(Date.now() + 1000 * 60).toISOString();

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<p>it works!</p>',
    scheduledAt: oneMinuteFromNow,
  });
  ```

  ```php PHP {3} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $oneMinuteFromNow = (new DateTime())->modify('+1 minute')->format(DateTime::ISO8601);

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'hello world',
    'html' => '<p>it works!</p>',
    'scheduled_at' => $oneMinuteFromNow
  ]);
  ```

  ```python Python {6} theme={null}
  import resend
  from datetime import datetime, timedelta

  resend.api_key = "re_xxxxxxxxx"

  one_minute_from_now = (datetime.now() + timedelta(minutes=1)).isoformat()

  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "scheduled_at": one_minute_from_now
  }

  resend.Emails.send(params)
  ```

  ```rb Ruby {5} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  one_minute_from_now = (Time.now + 1 * 60).strftime("%Y-%m-%dT%H:%M:%S.%L%z")

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "scheduled_at": one_minute_from_now
  }

  Resend::Emails.send(params)
  ```

  ```go Go {12} theme={null}
  import (
  	"fmt"

  	"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:        "Acme <onboarding@resend.dev>",
      To:          []string{"delivered@resend.dev"},
      Subject:     "hello world",
      Html:        "<p>it works!</p>",
      ScheduledAt: oneMinuteFromNowISO
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust {12-15} theme={null}
  use chrono::{Local, TimeDelta};
  use resend_rs::types::CreateEmailBaseOptions;
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "hello world";
    let one_minute_from_now = Local::now()
      .checked_add_signed(TimeDelta::minutes(1))
      .unwrap()
      .to_rfc3339();

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>it works!</p>")
      .with_scheduled_at(&one_minute_from_now);

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {7-10} theme={null}
  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("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("hello world")
                  .html("<p>it works!</p>")
                  .scheduledAt(oneMinuteFromNow)
                  .build();

          CreateEmailResponse data = resend.emails().send(params);
      }
  }
  ```

  ```csharp .NET {11} theme={null}
  using Resend;

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

  var resp = await resend.EmailSendAsync( new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
      MomentSchedule = DateTime.UtcNow.AddMinutes( 1 ),
  } );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {9} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "scheduled_at": "2024-08-20T11:52:01.858Z"
  }'
  ```
</CodeGroup>

## View a scheduled email

Once you schedule an email, you can see the scheduled time in the Resend dashboard.

<video />

## Reschedule an email

After scheduling an email, you might need to update the scheduled time.

You can do so with the following method:

<CodeGroup>
  ```ts Node.js {3} theme={null}
  resend.emails.update({
    id: '49a3999c-0ce1-4ea6-ab68-afcd6dc2e794',
    scheduledAt: 'in 1 min',
  });
  ```

  ```php PHP {2} theme={null}
  $resend->emails->update('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794', [
    'scheduled_at' => 'in 1 min'
  ]);
  ```

  ```python Python {3} theme={null}
  update_params: resend.Emails.UpdateParams = {
    "id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    "scheduled_at": "in 1 min"
  }

  resend.Emails.update(params=update_params)
  ```

  ```rb Ruby {3} theme={null}
  update_params = {
    "email_id": "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    "scheduled_at": "in 1 min"
  }

  updated_email = Resend::Emails.update(update_params)
  ```

  ```go Go {3} theme={null}
  updateParams := &resend.UpdateEmailRequest{
    Id:          "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794",
    ScheduledAt: "in 1 min",
  }

  updatedEmail, err := client.Emails.Update(updateParams)

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v\n", updatedEmail)
  ```

  ```rust Rust {2} theme={null}
  let update = UpdateEmailOptions::new()
    .with_scheduled_at("in 1 min");

  let _email = resend
    .emails
    .update("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", update)
    .await?;
  ```

  ```java Java {2} theme={null}
  UpdateEmailOptions updateParams = UpdateEmailOptions.builder()
    .scheduledAt("in 1 min")
    .build();

  UpdateEmailResponse data = resend.emails().update("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794", updateParams);
  ```

  ```csharp .NET {7} theme={null}
  using Resend;

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

  await resend.EmailRescheduleAsync(
    new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ),
    "in 1 min"
  );
  ```

  ```bash cURL {5} theme={null}
  curl -X PATCH 'https://api.resend.com/emails/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "scheduled_at": "in 1 min"
  }'
  ```
</CodeGroup>

You can also reschedule an email directly in the Resend dashboard.

<video />

## Cancel a scheduled email

<Warning>Once an email is canceled, it cannot be rescheduled.</Warning>

If you need to cancel a scheduled email, you can do so with the following code:

<CodeGroup>
  ```ts Node.js theme={null}
  resend.emails.cancel('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794');
  ```

  ```php PHP theme={null}
  $resend->emails->cancel('49a3999c-0ce1-4ea6-ab68-afcd6dc2e794');
  ```

  ```python Python theme={null}
  resend.Emails.cancel(email_id="49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
  ```

  ```rb Ruby theme={null}
  Resend::Emails.cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
  ```

  ```go Go theme={null}
  canceled, err := client.Emails.Cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
  if err != nil {
    panic(err)
  }
  fmt.Println(canceled.Id)
  ```

  ```rust Rust theme={null}
  let _canceled = resend
    .emails
    .cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794")
    .await?;
  ```

  ```java Java theme={null}
  CancelEmailResponse canceled = resend
      .emails()
      .cancel("49a3999c-0ce1-4ea6-ab68-afcd6dc2e794");
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  await resend.EmailCancelAsync( new Guid( "49a3999c-0ce1-4ea6-ab68-afcd6dc2e794" ) );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/emails/49a3999c-0ce1-4ea6-ab68-afcd6dc2e794/cancel' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</CodeGroup>

You can also cancel a scheduled email in the Resend dashboard.

<video />

## Scheduled email failures

Scheduled emails may fail to send for several reasons. When this happens, you'll see a failure notification in the email details screen with specific information about why the email couldn't be sent.

Common failure reasons include:

* **API key is no longer active** - The API key used to schedule the email has been deleted, expired, or suspended. The email cannot be sent.
* **Account under review** - Your account has been flagged for review and sending has been temporarily suspended. Contact [support@resend.com](mailto:support@resend.com) if you believe this is an error.

You can view the failure reason and details in the Resend dashboard by clicking on the failed email.

## Limitations

* Emails sent via SMTP cannot be scheduled


# Send Test Emails
Source: https://resend.com/docs/dashboard/emails/send-test-emails

Simulate different events by sending test emails.

## How to send test emails

During development, it's important to test different deliverability scenarios.

> **Example**: When an email hard bounces or is marked as spam, it's important to stop sending emails to the recipient, as continuing to send emails to those addresses will damage your domain reputation. We recommend [creating a webhook endpoint](/webhooks/introduction) to capture these events and remove the addresses from your mailing lists.

When testing, avoid:

* sending to fake email addresess
* setting up a fake SMTP server

We provide the following test email addresses to help you simulate different email events without damaging your domain reputation. These test emails enable the safe use of Resend's Dashboard, Webhooks, and API when developing your application.

All test email addresses support labeling, which enables you to send emails to the same test address in multiple ways. You can add a label after the `+` symbol (e.g., `delivered+label1@resend.dev`) to help track and differentiate between different test scenarios in your application.

## Test delivered emails

To test that your emails are being successfully delivered, you can send an email to:

```
delivered@resend.dev
```

With labeling support, you can also use:

```
delivered+user1@resend.dev
delivered+user2@resend.dev
delivered+user3@resend.dev
```

## Test bounced emails

To test that the recipient's email provider rejected your email, you can send an email to:

```
bounced@resend.dev
```

With labeling support, you can also use:

```
bounced+user1@resend.dev
bounced+user2@resend.dev
bounced+user3@resend.dev
```

This will generate a SMTP 550 5.1.1 ("Unknown User") response code.

## Test "Marked as Spam" emails

To test that your emails are being received but marked as spam, you can send an email to:

```
complained@resend.dev
```

With labeling support, you can also use:

```
complained+user1@resend.dev
complained+user2@resend.dev
complained+user3@resend.dev
```

## Using labels effectively

The labeling feature allows you to use any string as a label after the `+` symbol. This is particularly useful for:

* Testing different email flows (e.g., `delivered+signup@resend.dev`, `delivered+password-reset@resend.dev`)
* Tracking webhook responses for specific test scenarios
* Differentiating between multiple test runs
* Matching responses with the specific email address that triggered the event


# Managing Tags
Source: https://resend.com/docs/dashboard/emails/tags

Add unique identifiers to emails sent.

Tags are unique identifiers you can add to your emails. They help associate emails with your application. They are passed in key/value pairs. After the email is sent, the tag is included in the webhook event. Tags can include ASCII letters, numbers, underscores, or dashes.

Some examples of when to use a tag:

* Associate the email a "customer ID" from your application
* Add a label from your database like "free" or "enterprise"
* Note the category of email sent, like "welcome" or "password reset"

Here's how you can add custom tags to your emails.

## Add tags on the `POST /emails` endpoint

<CodeGroup>
  ```ts Node.js {10-15} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<p>it works!</p>',
    tags: [
      {
        name: 'category',
        value: 'confirm_email',
      },
    ],
  });
  ```

  ```php PHP {8-13} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'hello world',
    'html' => '<p>it works!</p>',
    'tags' => [
      [
        'name' => 'category',
        'value' => 'confirm_email',
      ],
    ]
  ]);
  ```

  ```python Python {10-12} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "tags": [
      {"name": "category", "value": "confirm_email"},
    ],
  }

  email = resend.Emails.send(params)
  print(email)
  ```

  ```rb Ruby {10-12} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  params = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "tags": [
      {"name": "category", "value": "confirm_email"}
    ]
  }

  sent = Resend::Emails.send(params)
  puts sent
  ```

  ```go Go {16} theme={null}
  import (
  	"fmt"

  	"github.com/resend/resend-go/v3"
  )

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

    params := &resend.SendEmailRequest{
        From:        "Acme <onboarding@resend.dev>",
        To:          []string{"delivered@resend.dev"},
        Text:        "<p>it works!</p>",
        Subject:     "hello world",
        Tags:        []resend.Tag{{Name: "category", Value: "confirm_email"}},
    }

    sent, err := client.Emails.SendWithContext(ctx, params)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Id)
  }
  ```

  ```rust Rust {14} theme={null}
  use resend_rs::types::{CreateEmailBaseOptions, Tag};
  use resend_rs::{Resend, Result};

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

    let from = "Acme <onboarding@resend.dev>";
    let to = ["delivered@resend.dev"];
    let subject = "hello world";

    let email = CreateEmailBaseOptions::new(from, to, subject)
      .with_html("<p>it works!</p>")
      .with_tag(Tag::new("category", "confirm_email"));

    let _email = resend.emails.send(email).await?;

    Ok(())
  }
  ```

  ```java Java {17} theme={null}
  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("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("hello world")
                  .html("<p>it works!</p>")
                  .tags(tag)
                  .build();

          SendEmailResponse data = resend.emails().send(sendEmailRequest);
      }
  }
  ```

  ```csharp .NET {12} theme={null}
  using Resend;

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

  var resp = await resend.EmailSendAsync( new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
      ReplyTo = "onboarding@resend.dev",
      Tags = new List<EmailTag> { new EmailTag { Name = "category", Value = "confirm_email" } }
  } );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL {9-14} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<p>it works!</p>",
    "tags": [
      {
        "name": "category",
        "value": "confirm_email"
      }
    ]
  }'
  ```
</CodeGroup>

## Add tags on the `POST /emails/batch` endpoint

<CodeGroup>
  ```ts Node.js {11-16,23-28} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.batch.send([
    {
      from: 'Acme <onboarding@resend.dev>',
      to: ['foo@gmail.com'],
      subject: 'hello world',
      html: '<h1>it works!</h1>',
      tags: [
        {
          name: 'category',
          value: 'confirm_email',
        },
      ],
    },
    {
      from: 'Acme <onboarding@resend.dev>',
      to: ['bar@outlook.com'],
      subject: 'world hello',
      html: '<p>it works!</p>',
      tags: [
        {
          name: 'category',
          value: 'confirm_email',
        },
      ],
    },
  ]);
  ```

  ```php PHP {9-13,21-25} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->batch->send([
    [
      'from' => 'Acme <onboarding@resend.dev>',
      'to' => ['foo@gmail.com'],
      'subject' => 'hello world',
      'html' => '<h1>it works!</h1>',
      'tags' => [
        [
          'name' => 'category',
          'value' => 'confirm_email'
        ]
      ]
    ],
    [
      'from' => 'Acme <onboarding@resend.dev>',
      'to' => ['bar@outlook.com'],
      'subject' => 'world hello',
      'html' => '<p>it works!</p>',
      'tags' => [
        [
          'name' => 'category',
          'value' => 'confirm_email'
        ]
      ]
    ]
  ]);
  ```

  ```py Python {12-17,24-29} theme={null}
  import resend
  from typing import List

  resend.api_key = "re_xxxxxxxxx"

  params: List[resend.Emails.SendParams] = [
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["foo@gmail.com"],
      "subject": "hello world",
      "html": "<h1>it works!</h1>",
      "tags": [
        {
          "name": "category",
          "value": "confirm_email"
        }
      ]
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["bar@outlook.com"],
      "subject": "world hello",
      "html": "<p>it works!</p>",
      "tags": [
        {
          "name": "category",
          "value": "confirm_email"
        }
      ]
    }
  ]

  resend.Batch.send(params)
  ```

  ```rb Ruby {11-16,23-28} theme={null}
  require "resend"

  Resend.api_key = 're_xxxxxxxxx'

  params = [
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["foo@gmail.com"],
      "subject": "hello world",
      "html": "<h1>it works!</h1>",
      "tags": [
        {
          "name": "category",
          "value": "confirm_email"
        }
      ]
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["bar@outlook.com"],
      "subject": "world hello",
      "html": "<p>it works!</p>",
      "tags": [
        {
          "name": "category",
          "value": "confirm_email"
        }
      ]
    }
  ]

  Resend::Batch.send(params)
  ```

  ```go Go {22,29} theme={null}
  package examples

  import (
  	"fmt"
  	"os"

  	"github.com/resend/resend-go/v3"
  )

  func main() {

    ctx := context.TODO()

    client := resend.NewClient("re_xxxxxxxxx")

    var batchEmails = []*resend.SendEmailRequest{
      {
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"foo@gmail.com"},
        Subject: "hello world",
        Html:    "<h1>it works!</h1>",
        Tags:    []resend.Tag{{Name: "category", Value: "confirm_email"}},
      },
      {
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"bar@outlook.com"},
        Subject: "world hello",
        Html:    "<p>it works!</p>",
        Tags:    []resend.Tag{{Name: "category", Value: "confirm_email"}},
      },
    }

    sent, err := client.Batch.SendWithContext(ctx, batchEmails)

    if err != nil {
      panic(err)
    }
    fmt.Println(sent.Data)
  }
  ```

  ```rust Rust {15,22} theme={null}
  use resend_rs::types::CreateEmailBaseOptions;
  use resend_rs::{Resend, Result};

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

    let emails = vec![
      CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        vec!["foo@gmail.com"],
        "hello world",
      )
      .with_html("<h1>it works!</h1>")
      .with_tag(Tag::new("category", "confirm_email")),
      CreateEmailBaseOptions::new(
        "Acme <onboarding@resend.dev>",
        vec!["bar@outlook.com"],
        "world hello",
      )
      .with_html("<p>it works!</p>")
      .with_tag(Tag::new("category", "confirm_email")),
    ];

    let _emails = resend.batch.send(emails).await?;

    Ok(())
  }
  ```

  ```java Java {12-15,23-26} theme={null}
  import com.resend.*;

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

          CreateEmailOptions firstEmail = CreateEmailOptions.builder()
              .from("Acme <onboarding@resend.dev>")
              .to("foo@gmail.com")
              .subject("hello world")
              .html("<h1>it works!</h1>")
              .tags(Tag.builder()
                  .name("category")
                  .value("confirm_email")
                  .build())
              .build();

          CreateEmailOptions secondEmail = CreateEmailOptions.builder()
              .from("Acme <onboarding@resend.dev>")
              .to("bar@outlook.com")
              .subject("world hello")
              .html("<p>it works!</p>")
              .tags(Tag.builder()
                  .name("category")
                  .value("confirm_email")
                  .build())
              .build();

          CreateBatchEmailsResponse data = resend.batch().send(
              Arrays.asList(firstEmail, secondEmail)
          );
      }
  }
  ```

  ```csharp .NET {11,20} theme={null}
  using Resend;

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

  var mail1 = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "foo@gmail.com",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
      Tags = new List<EmailTag> { new EmailTag { Name = "category", Value = "confirm_email" } }
  };

  var mail2 = new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "bar@outlook.com",
      Subject = "hello world",
      HtmlBody = "<p>it works!</p>",
      Tags = new List<EmailTag> { new EmailTag { Name = "category", Value = "confirm_email" } }
  };

  var resp = await resend.EmailBatchAsync( [ mail1, mail2 ] );
  Console.WriteLine( "Nr Emails={0}", resp.Content.Count );
  ```

  ```bash cURL {10-15,22-27} theme={null}
  curl -X POST 'https://api.resend.com/emails/batch' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'[
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["foo@gmail.com"],
      "subject": "hello world",
      "html": "<h1>it works!</h1>",
      "tags": [
        {
          "name": "category",
          "value": "confirm_email"
        }
      ]
    },
    {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["bar@outlook.com"],
      "subject": "world hello",
      "html": "<p>it works!</p>",
      "tags": [
        {
          "name": "category",
          "value": "confirm_email"
        }
      ]
    }
  ]'
  ```
</CodeGroup>


# Introduction
Source: https://resend.com/docs/dashboard/logs/introduction

Learn how to view and troubleshoot API logs in the Resend Dashboard.

## Overview

The Logs page provides detailed information about every API request made to Resend, helping you monitor activity and troubleshoot issues quickly.

## Viewing logs

Access your logs from the [Logs page](https://resend.com/logs) in the dashboard.

<img alt="Logs" />

Each log entry shows:

* **Endpoint** - The API endpoint called (e.g., `/domains`, `/api-keys`, `/contacts`)
* **Status** - The HTTP response status code (200, 201, etc.)
* **Method** - The HTTP method used (GET, POST, DELETE, etc.)
* **Created** - When the request was made (displayed as relative time)

## Searching Logs

Use the search bar to find specific logs. This is useful when tracking down a particular request or debugging an issue.

## Filtering Logs

Filter logs by response status to quickly identify issues:

* **All Statuses** - View all logs
* **Successes** - Show only successful requests (2xx status codes)
* **Errors** - Show only failed requests (4xx and 5xx status codes)
* **Specific codes** - Select one or more specific HTTP status codes (200, 201, 403, 429, etc.)

You can select multiple status codes to create custom filters.

* **Date range** - Adjust the time period for logs (e.g., Last 15 days)
* **User Agents** - Filter by SDK or client
* **API Keys** - Filter by specific API key

## Log details

Click any log entry to view complete details.

<img alt="Logs" />

### Request information

* **Request body** - The full JSON payload sent to the API (with copyable code blocks)
* **HTTP method** - GET, POST, etc.
* **Endpoint** - The API endpoint called
* **User-Agent** - The client or SDK used, with automatic SDK detection showing name and version

### Response information

* **Response body** - The complete API response (with copyable code blocks)
* **Status code** - The HTTP status code returned
* **Timestamp** - When the request was processed

### SDK detection

The dashboard automatically detects and displays Resend SDK information from the User-Agent header, showing:

* SDK name (e.g., "Resend Node.js")
* Version number

## Troubleshooting errors

For supported error types, click the **Help me fix** button to open a troubleshooting drawer.

<img alt="Logs" />

The drawer includes:

* **Raw response** - The complete API response
* **Detailed guidance** - Step-by-step instructions to resolve the issue
* **Relevant links** - Documentation and knowledge base articles
* **Contextual information** - Your current rate limits, verified domains, and other relevant data

<Note>
  View a comprehensive list of error codes and their meanings in the [Resend API
  Reference](/api-reference/errors).
</Note>

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

<Info>Currently, exports are limited to admin users of your team.</Info>

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

<Note>
  All exports your team creates are listed in the
  [Exports](https://resend.com/exports) page under **Settings** > **Team** >
  **Exports**. Select any export to view its details page. All members of your
  team can view your exports, but only admins can download the data.
</Note>


# Process Receiving Attachments
Source: https://resend.com/docs/dashboard/receiving/attachments

Process attachments from receiving emails.

A common use case for Receiving emails is to process attachments.

<Info>
  Webhooks do not include the actual content of attachments, only their
  metadata. You must call the [Attachments
  API](/api-reference/emails/list-received-email-attachments) to retrieve the
  content. This design choice supports large attachments in serverless
  environments that have limited request body sizes.
</Info>

Users can forward airplane tickets, receipts, and expenses to you. Then, you can extract key information from attachments and use that data.

To do this, call the [Attachments API](/api-reference/emails/list-received-email-attachments) after receiving the webhook event. That API will return a list of attachments with their metadata and a `download_url` that you can use to download the actual content.

Note that the `download_url` is valid for 1 hour. After that, you will need to call the
[Attachments API](/api-reference/emails/list-received-email-attachments)
again to get a new `download_url`. You can also check the `expires_at` field on
each attachment to see exactly when it will expire.

Here's an example of getting attachment data in a Next.js application:

```js app/api/events/route.ts theme={null}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    const { data: attachments } = await resend
      .emails
      .receiving
      .attachments
      .list({ emailId: event.data.email_id });

    for (const attachment of attachments) {
      // use the download_url to download attachments however you want
      const response = await fetch(attachment.download_url);
      if (!response.ok) {
        console.error(`Failed to download ${attachment.filename}`);
        continue;
      }

      // get the file's contents
      const buffer = Buffer.from(await response.arrayBuffer());

      // process the content (e.g., save to storage, analyze, etc.)
    }

    return NextResponse.json({ attachmentsProcessed: attachments.length });
  }

  return NextResponse.json({});
};
```

Once you process attachments, you may want to forward the email to another address. Learn more about [forwarding emails](/dashboard/receiving/forward-emails).


# Custom Receiving Domains
Source: https://resend.com/docs/dashboard/receiving/custom-domains

Receive emails using your own domain.

Besides [using Resend-managed domains](/dashboard/receiving/introduction), you can also receive emails using your own custom domain, such as `yourdomain.tld`.

Here's how to receive emails using a *new* custom domain.

## 1. Add the DNS record

First, [verify your domain](/dashboard/domains/introduction).

Receiving emails requires an extra [MX record](https://resend.com/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records) to work. You'll need to add this record to your DNS provider.

1. Go to the [Domains](https://resend.com/domains) page
2. Copy the MX record
3. Paste the MX record into your domain's DNS service

<img alt="Add DNS records for Receiving Emails" />

<Info>
  If you already have existing MX records for your domain (because you're already
  using it for a real inbox, for example), we recommend that you
  create a subdomain (e.g. `subdomain.yourdomain.tld`) and add the MX record
  there. This way, you can use Resend for receiving emails without affecting
  your existing email service. Note that you will *not* receive emails at Resend
  if the required `MX` record is not the lowest priority value for the domain.

  Alternatively, you can configure your email service to forward emails to an address
  that's configured in Resend or forward them directly to the SMTP server address
  that appears in the receiving `MX` record.
</Info>

## 2. Configure webhooks

Next, create a new webhook endpoint to receive email events.

1. Go to the [Webhooks](https://resend.com/webhooks) page
2. Click "Add Webhook"
3. Enter the URL of your webhook endpoint
4. Select the event type `email.received`
5. Click "Add"

<img alt="Add Webhook for Receiving Emails" />

## 3. Receive email events

In your application, create a new route that can accept `POST` requests.

For example, here's how you can add an API route in a Next.js application:

```js app/api/events/route.ts theme={null}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    return NextResponse.json(event);
  }

  return NextResponse.json({});
};
```

Once you receive the email event, you can process the email body and attachments. We also recommend implementing [webhook request verification](/webhooks/verify-webhooks-requests) to secure your webhook endpoint.

```json theme={null}
{
  "type": "email.received",
  "created_at": "2024-02-22T23:41:12.126Z",
  "data": {
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "created_at": "2024-02-22T23:41:11.894719+00:00",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "bcc": [],
    "cc": [],
    "message_id": "<example+123>",
    "subject": "Sending this example",
    "attachments": [
      {
        "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
        "filename": "avatar.png",
        "content_type": "image/png",
        "content_disposition": "inline",
        "content_id": "img001"
      }
    ]
  }
}
```

## Enabling receiving for an existing domain

If you already have a verified domain, you can enable receiving by using the toggle in the receiving section of the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

After enabling receiving, you'll see a modal showing the MX record that you need to add to your DNS provider to start receiving emails.

Once you add the MX record, confirm by clicking the "I've added the record" button and wait for the receiving record to show as "verified".

## FAQ

<AccordionGroup>
  <Accordion title="What happens if I already have MX records for my domain?">
    If you already have existing MX records for your domain, we recommend that you
    create a subdomain (e.g. `subdomain.yourdomain.tld`) and add the MX record
    there.

    That's because emails will usually only be delivered to the MX record with the lowest
    priority value. Therefore, if you add Resend's MX record to your root domain alongside existing MX records,
    it will either not receive any emails at all (if the existing MX records have a lower priority),
    or it will interfere with your existing email service (if Resend's MX record has a lower priority). If you
    use the same priority, email delivery will be unpredictable and may hit either Resend or your existing email
    service.

    If you still want to use the same domain both in for Resend and your day-to-day
    email service, you can also set up forwarding rules in your existing email service
    to forward emails to an address that's configured in Resend or forward them directly
    to the SMTP server address that appears in the receiving `MX` record.
  </Accordion>

  <Accordion title="I have already verified my domain for sending. Do I need to verify it again for receiving?">
    No, you do not need to verify your entire domain again. If you already have a
    verified domain for sending, you can simply enable receiving for that domain,
    add the required MX record to your DNS provider, and click "I've added the record"
    to start verifying *only* the MX record.
  </Accordion>
</AccordionGroup>


# Forward Receiving Emails
Source: https://resend.com/docs/dashboard/receiving/forward-emails

Forward Receiving emails to another email address.

Receiving emails can also be forwarded to another email address.

<Info>
  Webhooks do not include the actual HTML or Plain Text body of the email. You
  must call the [received emails
  API](/api-reference/emails/retrieve-received-email) to retrieve them. This
  design choice supports large payloads in serverless environments that have
  limited request body sizes.
</Info>

To forward an email, use the [Send Email API](/api-reference/emails/send-email).

After receiving the webhook event, call the [Receiving API](/api-reference/emails/retrieve-received-email) (and the [Attachments API](/api-reference/emails/list-received-email-attachments) if you want to include attachments). Then forward the email using the [Send Email API](/api-reference/emails/send-email).

Here's an example of forwarding an email in a Next.js application:

```js app/api/events/route.ts theme={null}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    const { data: email } = await resend
      .emails
      .receiving
      .get(event.data.email_id);

    const { data: attachments } = await resend
      .emails
      .receiving.attachments
      .list({ emailId: event.data.email_id });

    // download the attachments and encode them in base64
    for (const attachment of attachments.data) {
      const response = await fetch(attachment.download_url);
      const buffer = Buffer.from(await response.arrayBuffer());
      attachment.content = buffer.toString('base64');
    }

    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: event.data.subject,
      html: email.html,
      text: email.text,
      attachments: attachments.data
    });

    return NextResponse.json(data);
  }

  return NextResponse.json({});
};
```


# Get Email Content
Source: https://resend.com/docs/dashboard/receiving/get-email-content

Get the body and headers of a received email.

Receiving emails contain the HTML and Plain Text body of the email, as well as the headers.

<Info>
  Webhooks do not include the actual HTML or Plain Text body of the email. You
  must call the [received emails
  API](/api-reference/emails/retrieve-received-email) to retrieve them. This
  design choice supports large payloads in serverless environments that have
  limited request body sizes.
</Info>

After receiving the webhook event, call the [Receiving API](/api-reference/emails/retrieve-received-email).

Here's an example in a Next.js application:

```js app/api/events/route.ts theme={null}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    const { data: email } = await resend
      .emails
      .receiving
      .get(event.data.email_id);

    console.log(email.html);
    console.log(email.text);
    console.log(email.headers);

    return NextResponse.json(email);
  }

  return NextResponse.json({});
};
```


# Receiving Emails
Source: https://resend.com/docs/dashboard/receiving/introduction

Learn how to receive emails via webhooks.

Resend supports receiving emails (commonly called inbound) in addition to sending emails. This is useful for:

* Receiving support emails from users
* Processing forwarded attachments
* Replying to emails from customers

## How does it work

Resend processes all incoming emails for your receiving domain, parses the contents and attachments, and then sends a `POST` request to an endpoint that you choose.

To receive emails, you can either use a domain managed by Resend, or [set up a custom domain](/dashboard/receiving/custom-domains).

<img alt="Receiving email process" />

<Info>
  Importantly, *any email* sent to your receiving domain will be received by Resend and forwarded to your webhook. You can intelligently route based on the `to` field in the webhook event.

  For example, if your domain is `cool-hedgehog.resend.app`, you will receive
  emails sent to `anything@cool-hedgehog.resend.app`.

  The same applies to [custom domains](/dashboard/receiving/custom-domains). If
  your domain is `yourdomain.tld`, you will receive emails sent to
  `anything@yourdomain.tld`.
</Info>

Here's how to start receiving emails using a domain managed by Resend.

## 1. Get your `.resend.app` domain

Any emails sent to an `<anything>@<id>.resend.app` address will be received by Resend and forwarded to your webhook.

To see your Resend domain:

1. Go to the [emails page](https://resend.com/emails).
2. Select the ["Receiving" tab](https://resend.com/emails/receiving).
3. Click the three dots button and select "Receiving address."

<img alt="Get your Resend domain" />

## 2. Configure webhooks

1. Go to the [Webhooks](https://resend.com/webhooks) page.
2. Click `Add Webhook`.
3. Enter the URL of your webhook endpoint.
4. Select the event type `email.received`.
5. Click `Add`.

<Tip>
  For development, you can create a tunnel to your localhost server using a tool like
  [ngrok](https://ngrok.com/download) or [VS Code Port Forwarding](https://code.visualstudio.com/docs/debugtest/port-forwarding). These tools serve your local dev environment at a public URL you can use to test your local webhook endpoint.

  Example: `https://example123.ngrok.io/api/webhook`
</Tip>

<img alt="Add Webhook for Receiving Emails" />

## 3. Receive email events

In your application, create a new route that can accept `POST` requests.

For example, here's how you can add an API route in a Next.js application:

```js app/api/events/route.ts theme={null}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    return NextResponse.json(event);
  }

  return NextResponse.json({});
};
```

Once you receive the email event, you can process the email body and attachments. We also recommend implementing [webhook request verification](/webhooks/verify-webhooks-requests) to secure your webhook endpoint.

```json theme={null}
{
  "type": "email.received",
  "created_at": "2024-02-22T23:41:12.126Z",
  "data": {
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "created_at": "2024-02-22T23:41:11.894719+00:00",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "bcc": [],
    "cc": [],
    "message_id": "<example+123>",
    "subject": "Sending this example",
    "attachments": [
      {
        "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
        "filename": "avatar.png",
        "content_type": "image/png",
        "content_disposition": "inline",
        "content_id": "img001"
      }
    ]
  }
}
```

## What can you do with Receiving emails

Once you receive an email, you can process it in a variety of ways. Here are some common actions you can take:

* [Get email content](/dashboard/receiving/get-email-content)
* [Process attachments](/dashboard/receiving/attachments)
* [Forward emails to another address](/dashboard/receiving/forward-emails)
* [Reply to emails in the same thread](/dashboard/receiving/reply-to-emails)

<Info>
  Webhooks do not include the email body, headers, or attachments, only their
  metadata. You must call the the [Received emails
  API](/api-reference/emails/retrieve-received-email) or the [Attachments
  API](/api-reference/emails/list-received-email-attachments) to retrieve them.
  This design choice supports large attachments in serverless environments that
  have limited request body sizes.
</Info>

## FAQ

<AccordionGroup>
  <Accordion title="Will I receive emails for any address at my domain?">
    Yes. Once you add the MX record to your [custom domains](/dashboard/receiving/custom-domains), you will receive emails for
    any address at that domain.

    For example, if your domain is `yourdomain.tld`, you will receive
    emails sent to `<anything>@yourdomain.tld`. You can then filter or
    route based on the `to` field in the webhook event.

    The same applies if you use the domain managed by Resend. If the domain given to you is `cool-hedgehog.resend.app`,
    you'll receive any email send to `<anything>@cool-hedgehog.resend.app`.
  </Accordion>

  <Accordion title="Can I receive emails on a subdomain?">
    Yes. You can add the MX record to any subdomain (e.g.
    `subdomain.yourdomain.tld`) and receive emails there.
  </Accordion>

  <Accordion title="Should I add the `MX` records for my root domain or a subdomain?">
    If you already have existing MX records for your root domain, we recommend
    that you create a subdomain (e.g. `subdomain.yourdomain.tld`) and add the MX
    record there. This way, you can use Resend for receiving emails without
    affecting your existing email service.

    If you still want to use the same domain both in for Resend and your day-to-day
    email service, you can also set up forwarding rules in your existing email service
    to forward emails to an address that's configured in Resend or forward them directly
    to the SMTP server address that appears in the receiving `MX` record.
  </Accordion>

  <Accordion title="Will I lose my emails if my webhook endpoint is down?">
    No, you will not lose your emails. Resend stores emails as soon as they come
    in.

    Even if your webhook endpoint is down, you can still see your emails in
    the dashboard and retrieve them using the [Receiving
    API](/api-reference/emails/retrieve-received-email).

    Additionally, we will retry delivering the webhook event on the schedule
    described in our [webhooks documentation](/webhooks/introduction#faq)
    and you can also replay individual webhook events from the
    [webhooks](/webhooks/introduction) page in the dashboard.
  </Accordion>

  <Accordion title="How can I make sure that it's Resend who's sending me webhooks?">
    All of Resend's webhooks include a secret and headers that you can use to verify
    the authenticity of the request.

    In our SDKs, you can verify webhooks using
    `resend.webhooks.verify()`, as shown below.

    ```js theme={null}
    // throws an error if the webhook is invalid
    // otherwise, returns the parsed payload object
    const result = resend.webhooks.verify({
      payload: JSON.stringify(req.body),
      headers: {
        id: req.headers['svix-id'],
        timestamp: req.headers['svix-timestamp'],
        signature: req.headers['svix-signature'],
      },
      webhookSecret: process.env.RESEND_WEBHOOK_SECRET,
    })
    ```

    You can find more code samples and instructions on how to verify webhooks in our
    [webhook verification documentation](/webhooks/verify-webhooks-requests).
  </Accordion>
</AccordionGroup>


# Reply to Receiving Emails
Source: https://resend.com/docs/dashboard/receiving/reply-to-emails

Reply to Receiving emails in the same thread.

Email clients thread emails by using the `message_id` metadata.

If you want to reply to an email, you should add the `In-Reply-To` header set to the `message_id` of the received email. We also recommend setting the subject to start with `Re:` so that email clients can group the replies together.

Here's an example of replying to an email in a Next.js application:

```ts app/api/events/route.ts theme={null}
import type { NextRequest } from 'next/server';
import { NextResponse } from 'next/server';
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

export const POST = async (request: NextRequest) => {
  const event = await request.json();

  if (event.type === 'email.received') {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: `Re: ${event.data.subject}`,
      html: '<p>Thanks for your email!</p>',
      headers: {
        'In-Reply-To': event.data.message_id,
      },
      attachments,
    });

    return NextResponse.json(data);
  }

  return NextResponse.json({});
};
```

If you're replying multiple times within the same thread, make sure to also append
the previous `message_id`s to the `References` header, separated by spaces.
This helps email clients maintain the correct threading structure.

```js theme={null}
const previousReferences = ['<msg_id1@domain.com>', '<msg_id2@domain.com>'];

const { data, error } = await resend.emails.send({
  from: 'Acme <onboarding@resend.dev>',
  to: ['delivered@resend.dev'],
  subject: `Re: ${event.data.subject}`,
  html: '<p>Thanks for your email!</p>',
  headers: {
    'In-Reply-To': event.data.message_id,
    'References': [...previousReferences, event.data.message_id].join(' '),
  },
  attachments,
});
```


# Managing Segments
Source: https://resend.com/docs/dashboard/segments/introduction

Learn how to create, retrieve, and delete segments.

Segments are used to group and manage your [Contacts](/dashboard/audiences/contacts). Segments are not visible to your Contacts, but are used for your own internal Contact organization.

## Send emails to your Segment

Segments were designed to be used in conjunction with [Broadcasts](/dashboard/broadcasts/introduction). You can send a Broadcast to an Segment from the Resend dashboard or from the Broadcast API.

### From Resend's no-code editor

You can send emails to your Segment by creating a new Broadcast and selecting the Segment you want to send it to.

<img alt="Send emails to your Segment" />

You can include the Unsubscribe Footer in your Broadcasts, which will be automatically replaced with the correct link for each Contact.

### From the Broadcast API

You can also use our [Broadcast API](/api-reference/broadcasts/create-broadcast) to create and send a Broadcast to your Segment.

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

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

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

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

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Broadcasts.CreateParams = {
    "segment_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    "from": "Acme <onboarding@resend.dev>",
    "subject": "Hello, world!",
    "html": "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
  }

  resend.Broadcasts.create(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

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

  ```go Go theme={null}
  import "fmt"
  import 	"github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.CreateBroadcastRequest{
    SegmentId: "78261eea-8f8b-4381-83c6-79fa7120f1cf",
    From:       "Acme <onboarding@resend.dev>",
    Html:       "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
    Subject:    "Hello, world!",
  }

  broadcast, _ := client.Broadcasts.Create(params)
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::CreateBroadcastOptions, Resend, Result};

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

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

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

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

    Ok(())
  }
  ```

  ```java Java theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

  CreateBroadcastOptions params = CreateBroadcastOptions.builder()
      .segmentId("78261eea-8f8b-4381-83c6-79fa7120f1cf")
      .from("Acme <onboarding@resend.dev>")
      .subject("hello world")
      .html("Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}")
      .build();

  CreateBroadcastResponseSuccess data = resend.broadcasts().create(params);
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.BroadcastAddAsync(
      new BroadcastData()
      {
          DisplayName = "Example Broadcast",
          SegmentId = new Guid( "78261eea-8f8b-4381-83c6-79fa7120f1cf" ),
          From = "Acme <onboarding@resend.dev>",
          Subject = "Hello, world!",
          HtmlBody = "Hi {{{FIRST_NAME|there}}}, you can unsubscribe here: {{{RESEND_UNSUBSCRIBE_URL}}}",
      }
  );
  Console.WriteLine( "Broadcast Id={0}", resp.Content );
  ```

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

## How to customize the unsubscribe link in my Broadcast?

Resend generates a unique link for each recipient and each Broadcast. You can use `{{{RESEND_UNSUBSCRIBE_URL}}}` as the link target.

<img alt="Unsubscribe Link" />

## Automatic Unsubscribes

When you send emails to your Segment, Resend will automatically handle the unsubscribe flow for you.

<img alt="Automatic Unsubscribes" />

If a Contact unsubscribes from your emails, they will be presented with a preference page.

* If you don't have any [Topics](/dashboard/topics/introduction) configured, the Contact will be unsubscribed from all emails from your account.
* If you have [Topics](/dashboard/topics/introduction) configured, the Contact will be presented with a preference page where they can subscribe or unsubscribe from specific types of emails (all `public` Topics will be shown).

Learn more about [managing your unsubscribe list](/dashboard/audiences/managing-unsubscribe-list) or [customizing your unsubscribe page](/dashboard/settings/unsubscribe-page).

<Info>
  Whenever possible, you should add a [Topic to your
  Broadcast](/dashboard/topics/introduction), as this will allow your Contacts
  to unsubscribe from specific types of emails (instead of unsubscribing from
  all emails from your account).
</Info>

## Export your data

Admins can download your data in CSV format for the following resources:

* Emails
* Broadcasts
* Contacts
* Segments
* Domains
* Logs
* API keys

<Info>Currently, exports are limited to admin users of your team.</Info>

To start, apply filters to your data and click on the "Export" button. Confirm your filters before exporting your data.

<video />

If your exported data includes 1,000 items or less, the export will download immediately. For larger exports, you'll receive an email with a link to download your data.

All admins on your team can securely access the export for 7 days. Unavailable exports are marked as "Expired."

<Note>
  All exports your team creates are listed in the
  [Exports](https://resend.com/exports) page under **Settings** > **Team** >
  **Exports**. Select any export to view its details page. All members of your
  team can view your exports, but only admins can download the data.
</Note>


# Migrating from Audiences to Segments
Source: https://resend.com/docs/dashboard/segments/migrating-from-audiences-to-segments

Learn how to migrate from Audiences to Segments

We've recently changed how Contacts are segmented. Before, each Contact was part of one Audience and if you created another contact with the same email address in a different Audience, it would be a completely separate object.

In the new model, Contacts are now independent of Audiences, which are now called Segments. A Contact can be in zero, one or multiple Segments and still count as one when calculating your quota usage.

Contacts API endpoints that previously required an `audience_id` can now be used directly instead.

## What's changing?

We're moving to a **Global Contacts** model.

* **Before**: If a Contact with the same email appeared in multiple Segments, it was counted as multiple Contacts.
* **Now**: Each email address is treated as a single Contact across your team, even if it appears in multiple Segments.

The new model offers three concepts:

* **Contact**: a global entity linked to a specific email address.
* **Segment**: an internal segmentation tool for your team to organize sending.
* **Topic**: a user-facing tool for managing email preferences.

## Unsubscribing

Previously, when a contact clicked "unsubscribe," their contact status were marked was "Unsubscribed" only from the specific Audience used in that Broadcast.

From now on, contacts will see a preference page where they can:

* Unsubscribe from certain **Topics** (email's preference).
* Or unsubscribe from **everything** you send (update contact status).

## What you should do

If you've been using Audiences for both segmentation and unsubscribes, we recommend switching your unsubscribe logic to **Topics**:

1. Create a Topic for each type of email you send.
2. Assign the right users to each Topic.
3. Use Segments purely for your internal organization.

With this setup, when you send a Broadcast, your users can choose which Topics to unsubscribe from—or opt out completely.

For details on the new API endpoints view:

* [Contacts](/api-reference/contacts/create-contact)
* [Topics](/api-reference/topics/create-topic)
* [Segments](/api-reference/segments/create-segment)

## How can we help?

If you have a use case not covered here, [please reach out](https://resend.com/help). We'll make sure your transition is smooth.


# Managing Billing
Source: https://resend.com/docs/dashboard/settings/billing

Manage your account subscription and billing information

The [Billing](https://resend.com/settings/billing) page in the Settings section provides a clear view of your subscription details, billing email, payment method, and account invoices. From here, you can:

* View and manage your subscription - Upgrade, downgrade, or modify your current plan.
* Manage billing contacts - Ensure the right people receive billing-related notifications.
* Update payment information - Add or change your credit card or billing details.
* Access invoices - Download past invoices for your records.

For any other billing inquiries, please [contact support](https://resend.com/help).

## How to cancel your subscription

1. Go to the [Billing](https://resend.com/settings/billing) page.
2. Click on the three dots <span><Icon icon="ellipsis" /></span> next to your plan.
3. Select **Cancel Subscription** from the dropdown menu.

<img alt="Cancel subscription" />


# Managing Teams
Source: https://resend.com/docs/dashboard/settings/team

Manage your account across multiple teams

Resend allows multiple teams to be managed under a single email address. Each team is distinct, with its own API keys, billing, and usage.

## Inviting new members to a team

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Click **Invite**. Input an email address and select a role (**Admin** or **Member**).
   * **Members** have access to manage emails, domains and webhooks.
   * **Admins** have all Member permissions plus the ability to invite users, update payments, and delete the team.
3. The new member will receive an email invitation to join the team.

## Add a team avatar

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Click **Upload Image** next to the avatar placeholders.
3. Upload an image file to use as the team avatar.

<video />

## Switching between teams

After accepting an invite from the account owner, users can switch between teams:

1. Click on the **team name** in the top left corner of any Resend page.
2. A dropdown menu will appear, listing all the teams you belong to.
3. Select a team to switch between them.

<img alt="image" />

## Change the team member roles

As an admin of your team, you can change the role of members in your team.

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Find the user you want to change.
3. Select the more options button <span><Icon icon="ellipsis" /></span> and choose **Change role**.

<img alt="Change role popover visible for team member" />

Upon confirmation, your team member will be given the new role.

## Leave your Resend team

You can leave your team by following these steps:

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Under members, click on <span><Icon icon="ellipsis" /></span> next to your name for more options.
3. Select the **Leave Team** button.

Upon confirmation, you will leave your team.

<Note>
  If you are the last member of the team, leaving will permanently delete the
  team and all its data. You will be prompted to confirm this action by typing
  **DELETE**. If the team still has other members, but you are the only admin,
  you will be prompted to promote another member to admin before leaving.
</Note>


# Custom Unsubscribe Page
Source: https://resend.com/docs/dashboard/settings/unsubscribe-page

Customize your unsubscribe page

When sending to Resend Audiences, Resend can [automatically handle the unsubscribe flow for you](/dashboard/audiences/introduction#automatic-unsubscribes).

You can customize your unsubscribe page to match your brand. Your unsubscribe page is used for every domain on your team.

1. Navigate to your [**Unsubscribe Page**](https://resend.com/settings/unsubscribe-page).
2. Click **Edit**.

You can customize the following:

* **Title**: The title of the unsubscribe page.
* **Description**: The description of the unsubscribe page.
* **Logo**: The logo of the unsubscribe page.
* **Background Color**: The background color of the unsubscribe page.
* **Text Color**: The text color of the unsubscribe page.
* **Accent Color**: The accent color of the unsubscribe page.

<video />

<Note>
  Pro plan users or higher can also remove the “Powered by Resend” footer.
</Note>


# Using Templates
Source: https://resend.com/docs/dashboard/templates/introduction

Learn how to use templates to send emails.

Templates are stored on Resend and can be referenced when you send transactional emails. With Templates, define the structure and layout of a message and optionally include custom variables which will be replaced with the actual values when sending the email.

Send only the Template `id` and `variables` (instead of sending the HTML), and Resend will render your final email and send it out.

<CodeGroup>
  ```ts Node.js {8-14} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: 'delivered@resend.dev',
    template: {
      id: 'order-confirmation',
      variables: {
        PRODUCT: 'Vintage Macintosh',
        PRICE: 499,
      },
    },
  });
  ```

  ```php PHP {7-12} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'hello world',
    'template'=> [
      'id' => 'f3b9756c-f4f4-44da-bc00-9f7903c8a83f',
      'variables' => [
        'PRODUCT' => 'Vintage Macintosh',
        'PRICE' => 499,
      ]
    ]
  ]);
  ```

  ```python Python {8-14} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Emails.send({
    "from": "Acme <onboarding@resend.dev>",
    "to": "delivered@resend.dev",
    "template": {
      "id": "order-confirmation",
      "variables": {
        "PRODUCT": "Vintage Macintosh",
        "PRICE": 499
      }
    }
  })
  ```

  ```ruby Ruby {8-14} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Emails.send({
    from: "Acme <onboarding@resend.dev>",
    to: "delivered@resend.dev",
    template: {
      id: "order-confirmation",
      variables: {
        PRODUCT: "Vintage Macintosh",
        PRICE: 499
      }
    }
  })
  ```

  ```go Go {8-14} theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.SendEmailRequest{
    From: "Acme <onboarding@resend.dev>",
    To: []string{"delivered@resend.dev"},
    Template: &resend.EmailTemplate{
      Id: "order-confirmation",
      Variables: map[string]interface{}{
        "PRODUCT": "Vintage Macintosh",
        "PRICE": 499,
      },
    },
  }

  email, err := client.Emails.Send(params)
  ```

  ```rust Rust {7-13} theme={null}
  use resend_rs::{types::SendEmailOptions, Resend, Result};

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

    let variables = serde_json::json!({
      "PRODUCT": "Vintage Macintosh",
      "PRICE": 499
    });

    let opts = SendEmailOptions::new("Acme <onboarding@resend.dev>", vec!["delivered@resend.dev"])
      .with_template("order-confirmation", variables);

    let _email = resend.emails.send(opts).await?;

    Ok(())
  }
  ```

  ```java Java {3-5,10-13} theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

  Map<String, Object> variables = new HashMap<>();
  variables.put("PRODUCT", "Vintage Macintosh");
  variables.put("PRICE", 499);

  SendEmailOptions params = SendEmailOptions.builder()
    .from("Acme <onboarding@resend.dev>")
    .to(Arrays.asList("customer@email.com"))
    .template(Template.builder()
      .id("order-confirmation")
      .variables(variables)
      .build())
    .build();

  SendEmailResponseSuccess data = resend.emails().send(params);
  ```

  ```csharp .NET {5-9,17-20} theme={null}
  using Resend;

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

  var variables = new Dictionary<string, object>
  {
    { "PRODUCT", "Vintage Macintosh" },
    { "PRICE", 499 }
  };

  var resp = await resend.EmailSendAsync(
    new EmailMessage()
    {
      From = "Acme <onboarding@resend.dev>",
      To = new[] { "delivered@resend.dev" },
      Template = new EmailMessageTemplate()
      {
        TemplateId = new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ),
        Variables = variables
      }
    }
  );

  Console.WriteLine($"Email Id={resp.Content}");
  ```

  ```bash cURL {7-13} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json' \
    -d $'{
      "from": "Acme <onboarding@resend.dev>",
      "to": "delivered@resend.dev",
      "template": {
        "id": "order-confirmation",
        "variables": {
          "PRODUCT": "Vintage Macintosh",
          "PRICE": 499
        }
      }
  }'
  ```
</CodeGroup>

Use Templates for transactional emails like:

* Login/Auth
* Onboarding
* Ecommerce
* Notifications
* Automations

## Add a Template

You can add a Template:

* [In the dashboard](#add-a-template-in-the-dashboard)
* [From an existing email](#add-a-template-from-an-existing-email)
* [Using the API](#create-a-template-by-using-the-api)

### Add a Template in the dashboard

The [Templates dashboard](https://resend.com/templates) shows all existing templates. Click **Create template** to start a new Template.

<img alt="Add a template" />

### Add a Template from an existing email

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 <span><Icon icon="ellipsis" /></span>, and choose **Clone as template**.

<img alt="Add a template from an existing email" />

You can also import an HTML or [React Email](https://react.email) file to create a Template from your existing code. Create a new Template, then paste or drag in your HTML or React Email content.

### Create a Template by using the API

You can also programmatically create a Template by using the API. The payload can optionally include variables to be used in the Template.

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.templates.create({
    name: 'order-confirmation',
    from: 'Resend Store <store@resend.com>',
    subject: 'Thanks for your order!',
    html: '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
    variables: [
      {
        key: 'PRODUCT',
        type: 'string',
        fallbackValue: 'item',
      },
      {
        key: 'PRICE',
        type: 'number',
        fallbackValue: 20,
      },
    ],
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->templates->create([
    'name' => 'order-confirmation',
    'from' => 'Resend Store <store@resend.com>',
    'subject' => 'Thanks for your order!',
    'html' => '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
    'variables' => [
      [
        'key' => 'PRODUCT',
        'type' => 'string',
        'fallback_value' => 'item'
      ],
      [
        'key' => 'PRICE',
        'type' => 'number',
        'fallback_value' => 49.99
      ]
    ]
  ]);
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Templates.CreateParams = {
      "name": "order-confirmation",
      "from": "Resend Store <store@resend.com>",
      "subject": "Thanks for your order!",
      "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
      "variables": [
          {
              "key": "PRODUCT",
              "type": "string",
              "fallback_value": "item",
          },
          {
              "key": "PRICE",
              "type": "number",
              "fallback_value": 20,
          },
      ],
  }

  resend.Templates.create(params)
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Templates.create(
    name: "order-confirmation",
    from: "Resend Store <store@resend.com>",
    subject: "Thanks for your order!",
    html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    variables: [
      {
        key: "PRODUCT",
        type: "string",
        fallback_value: "item"
      },
      {
        key: "PRICE",
        type: "number",
        fallback_value: 20
      }
    ]
  )
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  template, err := client.Templates.Create(&resend.CreateTemplateRequest{
  	Name:    "order-confirmation",
  	From:    "Resend Store <store@resend.com>",
  	Subject: "Thanks for your order!",
  	Html:    "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  	Variables: []*resend.TemplateVariable{
  		{
  			Key:           "PRODUCT",
  			Type:          resend.VariableTypeString,
  			FallbackValue: "item",
  		},
  		{
  			Key:           "PRICE",
  			Type:          resend.VariableTypeNumber,
  			FallbackValue: 20,
  		},
  	},
  })
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    types::{CreateTemplateOptions, Variable, VariableType},
    Resend, Result,
  };

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

    let name = "order-confirmation";
    let from = "Resend Store <store@resend.com>";
    let subject = "Thanks for your order!";
    let html = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>";

    let variables = [
      Variable::new("PRODUCT", VariableType::String).with_fallback("item"),
      Variable::new("PRICE", VariableType::Number).with_fallback(20)
    ];

    let opts = CreateTemplateOptions::new(name, 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={null}
  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 Store <store@resend.com>")
                  .subject("Thanks for your order!")
                  .html("<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>")
                  .addVariable(new Variable("PRODUCT", VariableType.STRING, "item"))
                  .addVariable(new Variable("PRICE", VariableType.NUMBER, 20))
                  .build();

          CreateTemplateResponseSuccess data = resend.templates().create(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var variables = new List<TemplateVariable>
  {
    new TemplateVariable() {
      Key = "PRODUCT",
      Type = TemplateVariableType.String,
      Default = "item",
    },
    new TemplateVariable() {
      Key = "PRICE",
      Type = TemplateVariableType.Number,
      Default = 20,
    },
  };

  var resp = await resend.TemplateCreateAsync(
    new TemplateData()
    {
      Name = "order-confirmation",
      From = "Resend Store <store@resend.com>",
      Subject = "Thanks for your order!",
      HtmlBody = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
      Variables = variables,
    }
  );

  Console.WriteLine($"Template Id={resp.Content}");
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/templates' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "order-confirmation",
    "from": "Resend Store <store@resend.com>",
    "subject": "Thanks for your order!",
    "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    "variables": [
      {
        "key": "PRODUCT",
        "type": "string",
        "fallback_value": "item"
      },
      {
        "key": "PRICE",
        "type": "number",
        "fallback_value": 20
      }
    ]
  }'
  ```
</CodeGroup>

View the [API reference](/api-reference/templates/create-template) for more details.

## Add Variables

Each Template may contain up to 20 variables.

To add a custom variable, select **Variable** in the commands palette or type `{{` in the editor. Define the `name`, `type`, and `fallback_value` (optional).

<img alt="variable dropdown" />

You can also define custom variables [via the API](/dashboard/templates/template-variables).

<Info>
  The following variable names are reserved and cannot be used: `FIRST_NAME`,
  `LAST_NAME`, `EMAIL`, `RESEND_UNSUBSCRIBE_URL`, `contact`,`this`.
</Info>

[Learn more about working with variables](/dashboard/templates/template-variables).

## Send Test Emails

You can send test emails to your inbox to preview your Template before sending it to your audience. Provide variable values to test the rendered Template in your inbox.

<video />

## Publish a Template

By default, Templates are in a **draft** state. To use a Template to send emails, you must first **publish** it via the dashboard or [via the API](/api-reference/templates/publish-template).

<img alt="Publish a template" />

For a more streamlined flow, create and publish a template in a single step.

```ts Node.js theme={null}
await resend.templates.create({ ... }).publish();
```

Once a Template is published, you can continue to edit it without impacting existing emails sent using the Template. As you work, your changes are saved as a draft, although you can also manually save drafts by pressing <kbd>Cmd</kbd> + <kbd>S</kbd> (Mac) or <kbd>Ctrl</kbd> + <kbd>S</kbd> (Windows).

Only after publishing again will the changes be reflected in emails using the Template.

[Learn more about Template version history](/dashboard/templates/version-history).

## Send Emails with Templates

When sending a transactional email, you can reference your Template and include your variables in the call. The Template variables will be replaced with the actual values.

<CodeGroup>
  ```ts Node.js {8-14} theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: 'delivered@resend.dev',
    template: {
      id: 'order-confirmation',
      variables: {
        PRODUCT: 'Vintage Macintosh',
        PRICE: 499,
      },
    },
  });
  ```

  ```php PHP {7-12} theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'hello world',
    'template'=> [
      'id' => 'f3b9756c-f4f4-44da-bc00-9f7903c8a83f',
      'variables' => [
        'PRODUCT' => 'Vintage Macintosh',
        'PRICE' => 499,
      ]
    ]
  ]);
  ```

  ```python Python {8-14} theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Emails.send({
    "from": "Acme <onboarding@resend.dev>",
    "to": "delivered@resend.dev",
    "template": {
      "id": "order-confirmation",
      "variables": {
        "PRODUCT": "Vintage Macintosh",
        "PRICE": 499
      }
    }
  })
  ```

  ```ruby Ruby {8-14} theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Emails.send({
    from: "Acme <onboarding@resend.dev>",
    to: "delivered@resend.dev",
    template: {
      id: "order-confirmation",
      variables: {
        PRODUCT: "Vintage Macintosh",
        PRICE: 499
      }
    }
  })
  ```

  ```go Go {8-14} theme={null}
  import "github.com/resend/resend-go/v3"

  client := resend.NewClient("re_xxxxxxxxx")

  params := &resend.SendEmailRequest{
    From: "Acme <onboarding@resend.dev>",
    To: []string{"delivered@resend.dev"},
    Template: &resend.EmailTemplate{
      Id: "order-confirmation",
      Variables: map[string]interface{}{
        "PRODUCT": "Vintage Macintosh",
        "PRICE": 499,
      },
    },
  }

  email, err := client.Emails.Send(params)
  ```

  ```rust Rust {7-13} theme={null}
  use resend_rs::{types::SendEmailOptions, Resend, Result};

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

    let variables = serde_json::json!({
      "PRODUCT": "Vintage Macintosh",
      "PRICE": 499
    });

    let opts = SendEmailOptions::new("Acme <onboarding@resend.dev>", vec!["delivered@resend.dev"])
      .with_template("order-confirmation", variables);

    let _email = resend.emails.send(opts).await?;

    Ok(())
  }
  ```

  ```java Java {3-5,10-13} theme={null}
  Resend resend = new Resend("re_xxxxxxxxx");

  Map<String, Object> variables = new HashMap<>();
  variables.put("PRODUCT", "Vintage Macintosh");
  variables.put("PRICE", 499);

  SendEmailOptions params = SendEmailOptions.builder()
    .from("Acme <onboarding@resend.dev>")
    .to(Arrays.asList("customer@email.com"))
    .template(Template.builder()
      .id("order-confirmation")
      .variables(variables)
      .build())
    .build();

  SendEmailResponseSuccess data = resend.emails().send(params);
  ```

  ```csharp .NET {5-9,17-20} theme={null}
  using Resend;

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

  var variables = new Dictionary<string, object>
  {
    { "PRODUCT", "Vintage Macintosh" },
    { "PRICE", 499 }
  };

  var resp = await resend.EmailSendAsync(
    new EmailMessage()
    {
      From = "Acme <onboarding@resend.dev>",
      To = new[] { "delivered@resend.dev" },
      Template = new EmailMessageTemplate()
      {
        TemplateId = new Guid( "b6d24b8e-af0b-4c3c-be0c-359bbd97381e" ),
        Variables = variables,
      }
    }
  );

  Console.WriteLine($"Email Id={resp.Content}");
  ```

  ```bash cURL {7-13} theme={null}
  curl -X POST 'https://api.resend.com/emails' \
    -H 'Authorization: Bearer re_xxxxxxxxx' \
    -H 'Content-Type: application/json' \
    -d $'{
      "from": "Acme <onboarding@resend.dev>",
      "to": "delivered@resend.dev",
      "template": {
        "id": "order-confirmation",
        "variables": {
          "PRODUCT": "Vintage Macintosh",
          "PRICE": 499
        }
      }
  }'
  ```
</CodeGroup>

Learn more about [sending emails](/api-reference/emails/send-email) or sending [batch emails](/api-reference/emails/send-batch-emails) with Templates via the API.

## Duplicate a Template

You can also duplicate an existing Template in the dashboard or [via the API](/api-reference/templates/duplicate-template).

<img alt="Duplicate a template" />

<Info>
  <p>
    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

    <span>
      <Icon icon="ellipsis" />
    </span>

    , and choose **Clone as template**.
  </p>
</Info>

## Delete a Template

You can delete a Template via the dashboard by clicking on the **Delete** button or [via the API](/api-reference/templates/delete-template).

<img alt="Delete a template" />

## Validation errors

When sending an email using a Template, the Template variables will be replaced with the actual values. If a variable is not provided, the fallback value will be used. If no fallback value is provided, the email will not be sent and a validation error will be returned.

[See the API reference for more details](/api-reference/templates/create-template) or the [errors reference](/api-reference/errors).


# Working with Variables
Source: https://resend.com/docs/dashboard/templates/template-variables

How to work with custom variables in Templates.

Custom Template variables provide your team flexibility when sending emails. Define custom variables for your Template with optional fallback values which will be replaced with the actual values when sending the email.

## Create custom variables

Each Template may contain up to 50 variables.

To add a custom variable, select **Variable** in the commands palette or type `{{` in the editor. Define the `name`, `type`, and `fallback_value` (optional).

<img alt="variable dropdown" />

<p>
  You can also define custom variables via the API. The payload can optionally
  include variables to be used in the Template.
</p>

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.templates.create({
    name: 'order-confirmation',
    html: '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
    variables: [
      {
        key: 'PRODUCT',
        type: 'string',
        fallbackValue: 'item',
      },
      {
        key: 'PRICE',
        type: 'number',
        fallbackValue: 25,
      },
    ],
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->templates->create([
    'name' => 'order-confirmation',
    'html' => '<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>',
    'variables' => [
      [
        'key' => 'PRODUCT',
        'type' => 'string',
        'fallback_value' => 'item',
      ],
      [
        'key' => 'PRICE',
        'type' => 'number',
        'fallback_value' => 25,
      ]
    ],
  ]);
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  resend.Templates.create({
      "name": "order-confirmation",
      "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
      "variables": [
          {
              "key": "PRODUCT",
              "type": "string",
              "fallback_value": "item",
          },
          {
              "key": "PRICE",
              "type": "number",
              "fallback_value": 25,
          }
      ],
  })
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  Resend::Templates.create(
    name: "order-confirmation",
    html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    variables: [
      {
        key: "PRODUCT",
        type: "string",
        fallback_value: "item"
      },
      {
        key: "PRICE",
        type: "number",
        fallback_value: 25
      }
    ]
  )
  ```

  ```go Go theme={null}
  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: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
  		Variables: []*resend.TemplateVariable{
  			{
  				Key:           "PRODUCT",
  				Type:          resend.VariableTypeString,
  				FallbackValue: "item",
  			},
  			{
  				Key:           "PRICE",
  				Type:          resend.VariableTypeNumber,
  				FallbackValue: 25,
  			}
  		},
  	})
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{
    types::{CreateTemplateOptions, Variable, VariableType},
    Resend, Result,
  };

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

    let name = "order-confirmation";
    let html = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>";

    let variables = [
      Variable::new("PRODUCT", VariableType::String).with_fallback("item"),
      Variable::new("PRICE", VariableType::Number).with_fallback(25)
    ];

    let opts = CreateTemplateOptions::new(name, html).with_variables(&variables);
    let template = resend.templates.create(opts).await?;

    let _published = resend.templates.publish(&template.id).await?;

    Ok(())
  }
  ```

  ```java Java theme={null}
  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("<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>")
                  .addVariable(new Variable("PRODUCT", VariableType.STRING, "item"))
                  .addVariable(new Variable("PRICE", VariableType.NUMBER, 25))
                  .build();

          CreateTemplateResponseSuccess data = resend.templates().create(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var variables = new List<TemplateVariable>()
  {
    new TemplateVariable() {
      Key = "PRODUCT",
      Type = TemplateVariableType.String,
      Default = "item",
    },
    new TemplateVariable() {
      Key = "PRICE",
      Type = TemplateVariableType.Number,
      Default = 25,
    }
  };

  var resp = await resend.TemplateCreateAsync(
    new TemplateData()
    {
      Name = "welcome-email",
      HtmlBody = "<strong>Hey, {{{PRODUCT}}}, you are {{{PRICE}}} years old.</strong>",
      Variables = variables,
    }
  );

  Console.WriteLine($"Template Id={resp.Content}");
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/templates' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "name": "order-confirmation",
    "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    "variables": [
      {
        "key": "PRODUCT",
        "type": "string",
        "fallback_value": "item"
      },
      {
        "key": "PRICE",
        "type": "number",
        "fallback_value": 25
      }
    ]
  }'
  ```
</CodeGroup>

<Info>
  The following variable names are reserved and cannot be used: `FIRST_NAME`,
  `LAST_NAME`, `EMAIL`, `UNSUBSCRIBE_URL`, `contact`,`this`.
</Info>

Each variable is an object with the following properties:

* `key`: The key of the variable. We recommend capitalizing the key. (e.g. `PRODUCT_NAME`).
* `type`: The type of the variable (`'string'` or `'number'`).
* `fallback_value`: The fallback value of the variable. If no fallback value is provided, you must provide a value for the variable when sending an email using the template.

[See the API reference for more details](/api-reference/templates/create-template).

## Fallback values

When you define a variable, you can optionally define a fallback value. This value will be used when sending the email if you fail to provide a value in your call.

<video />

In the editor, if you fail to provide a fallback value, a warning sign will show for the variable, which you can remove by providing a value.

[As shown above](#create-template-with-variables), you can also include fallback values when creating a Template via the API.

## Send Test Emails

You can send test emails to your inbox to preview your Template before sending it to your audience. Provide variable values to test the rendered Template in your inbox.

<video />

## Send a Template with Variables

When sending a transactional email, you can reference your Template and include your variables in the call. The Template variables will be replaced with the actual values.

* `id`: id of the published template
* `variables`: array of variable objects (if applicable)

Both the `/emails` and `/emails/batch` endpoints support Templates.

<CodeGroup>
  ```ts Node.js theme={null}
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    template: {
      id: 'f3b9756c-f4f4-44da-bc00-9f7903c8a83f',
      variables: {
        PRODUCT: 'Laptop',
      },
    },
  });
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  $resend->emails->send([
    'from' => 'Acme <onboarding@resend.dev>',
    'to' => ['delivered@resend.dev'],
    'subject' => 'hello world',
    'template'=> [
      'id' => 'f3b9756c-f4f4-44da-bc00-9f7903c8a83f',
      'variables' => [
        'PRODUCT' => 'Laptop'
      ]
    ]
  ]);
  ```

  ```python Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  params: resend.Emails.SendParams = {
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "hello world",
      "template": {
          "id": "f3b9756c-f4f4-44da-bc00-9f7903c8a83f",
          "variables": {
              "PRODUCT": "Laptop",
          },
      },
  }

  email = resend.Emails.send(params)
  ```

  ```ruby Ruby theme={null}
  require 'resend'

  Resend.api_key = 're_xxxxxxxxx'

  params = {
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    template: {
      id: 'f3b9756c-f4f4-44da-bc00-9f7903c8a83f',
      variables: {
        'PRODUCT': 'Laptop'
      }
    }
  }

  email = Resend::Emails.send(params)
  ```

  ```go Go theme={null}
  import (
  	"context"

  	"github.com/resend/resend-go/v3"
  )

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

  	params := &resend.SendEmailRequest{
  		From:    "Acme <onboarding@resend.dev>",
  		To:      []string{"delivered@resend.dev"},
  		Subject: "hello world",
  		Template: &resend.EmailTemplate{
  			ID: "f3b9756c-f4f4-44da-bc00-9f7903c8a83f",
  			Variables: map[string]interface{}{
  				"PRODUCT": "Laptop",
  			},
  		},
  	}

  	sent, err := client.Emails.SendWithContext(context.TODO(), params)
  }
  ```

  ```rust Rust theme={null}
  use resend_rs::{types::CreateEmailBaseOptions, Resend, Result};
  use std::collections::HashMap;

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

  	let from = "Acme <onboarding@resend.dev>";
  	let to = ["delivered@resend.dev"];
  	let subject = "hello world";

  	let mut variables = HashMap::new();
  	variables.insert("PRODUCT".to_string(), "Laptop".to_string());

  	let email = CreateEmailBaseOptions::new(from, to, subject)
  		.with_template("f3b9756c-f4f4-44da-bc00-9f7903c8a83f", variables);

  	let _email = resend.emails.send(email).await?;

  	Ok(())
  }
  ```

  ```java Java theme={null}
  import com.resend.*;
  import java.util.HashMap;
  import java.util.Map;

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

          Map<String, Object> variables = new HashMap<>();
          variables.put("PRODUCT", "Laptop");

          CreateEmailOptions params = CreateEmailOptions.builder()
                  .from("Acme <onboarding@resend.dev>")
                  .to("delivered@resend.dev")
                  .subject("hello world")
                  .template("f3b9756c-f4f4-44da-bc00-9f7903c8a83f", variables)
                  .build();

          CreateEmailResponse data = resend.emails().send(params);
      }
  }
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  var resp = await resend.EmailSendAsync( new EmailMessage()
  {
      From = "Acme <onboarding@resend.dev>",
      To = "delivered@resend.dev",
      Subject = "hello world",
      Template = new EmailMessageTemplate() {
        TemplateId = new Guid( "f3b9756c-f4f4-44da-bc00-9f7903c8a83f" ),
        Variables = new Dictionary<string, object>()
        {
          { "PRODUCT", "Laptop" },
          { "PRICE", 1.23 }
        }
      }
  } );
  Console.WriteLine( "Email Id={0}", resp.Content );
  ```

  ```bash cURL theme={null}
  curl -X POST 'https://api.resend.com/emails' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json' \
       -d $'{
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "template": {
      "id": "f3b9756c-f4f4-44da-bc00-9f7903c8a83f",
      "variables": {
        "PRODUCT": "Laptop"
      }
    }
  }'
  ```
</CodeGroup>

<Info>
  If a `template` is provided, you cannot send `html`, `text`, or `react` in the payload, otherwise the API will return a validation error.

  When sending a template, the payload for `from`, `subject`, and `reply_to` take precedence over the template's defaults for these fields. If the template does not provide a default value for these fields, you must provide them in the payload.
</Info>

Learn more about [sending emails](/api-reference/emails/send-email) or sending [batch emails](/api-reference/emails/send-batch-emails) with Templates via the API.


# Version History
Source: https://resend.com/docs/dashboard/templates/version-history

Best practices for using templates in production environments.

Templates in production require a workflow that lets you make changes safely without disrupting active emails. As you build your Template, your entire team can collaborate on the content and design in real-time with full version history.

## Draft vs Published

Templates start in a **draft** state and must be published before they can be used to send emails.

This separation allows you to:

* Test templates thoroughly before going live
* Make changes without affecting active emails
* Maintain version control over your email content

Once you **publish** a template, this published version will be used to send emails until you publish again. You can continue to work on a template in draft state without affecting the published version and the editor will automaticalyl save your progress.

<CodeGroup>
  ```ts Node.js theme={null}
  // Create template
  import { Resend } from 'resend';

  const resend = new Resend('re_xxxxxxxxx');

  await resend.templates.create({
    name: 'order-confirmation',
    from: 'Resend Store <store@resend.com>',
    subject: 'Thanks for your order!',
    html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    variables: [
      {
        key: 'PRODUCT',
        type: 'string',
        fallbackValue: 'item'
      },
      {
        key: 'PRICE',
        type: 'number',
        fallbackValue: 20
      }
    ]
  });

  // Publish template
  await resend.templates.publish('template_id');

  // Or create and publish a template in one step
  await resend.templates.create({ ... }).publish();
  ```

  ```php PHP theme={null}
  $resend = Resend::client('re_xxxxxxxxx');

  // Create template
  $resend->templates->create([
    'name' => 'order-confirmation',
    'from' => 'Resend Store <store@resend.com>',
    'subject' => 'Thanks for your order!',
      'html' => "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    'variables' => [
      [
        'key' => 'PRODUCT',
        'type' => 'string',
        'fallbackValue' => 'item'
      ],
      [
        'key' => 'PRICE',
        'type' => 'number',
        'fallbackValue' => 49.99
      ]
    ]
  ]);

  // Publish template
  $resend->templates->publish('template_id');
  ```

  ```py Python theme={null}
  import resend

  resend.api_key = "re_xxxxxxxxx"

  // Create template
  params: resend.Templates.CreateParams = {
    "name": "order-confirmation",
    "from": "Resend Store <store@resend.com>",
    "subject": "Thanks for your order!",
    "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    "variables": [
      {
        "key": "PRODUCT",
        "type": "string",
        "fallbackValue": "item"
      },
      {
        "key": "PRICE",
        "type": "number",
        "fallbackValue": 20
      },
    ]
  }

  resend.Templates.create(params)

  // Publish template
  resend.Templates.publish('template_id');
  ```

  ```ruby Ruby theme={null}
  require "resend"

  Resend.api_key = "re_xxxxxxxxx"

  // Create template
  params = {
    "name": 'order-confirmation',
    "from": 'Resend Store <store@resend.com>',
    "subject": 'Thanks for your order!',
    "html": "<p>Name: #{{{PRODUCT}}}</p><p>Total: #{{{PRICE}}}</p>",
    "variables": [{
        "key": 'PRODUCT',
        "type": 'string',
        "fallbackValue": 'item'
      },
      {
        "key": 'PRICE',
        "type": 'number',
        "fallbackValue": 20
      }
    ]
  }

  Resend::Templates.create(params)

  // Publish template
  Resend::Templates.publish('template_id');
  ```

  ```go Go theme={null}
  import "github.com/resend/resend-go/v2"

  client := resend.NewClient("re_xxxxxxxxx")

  // Create template
  params := &resend.CreateTemplateRequest{
    Name: "order-confirmation",
    From: "Resend Store <store@resend.com>",
    Subject: "Thanks for your order!",
    Html: "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    Variables: []resend.TemplateVariable{
      {
        Key: "PRODUCT",
        Type: "string",
        FallbackValue: "item",
      },
      {
        Key: "PRICE",
        Type: "number",
        FallbackValue: 20,
      },
    },
  }

  template, _ := client.Templates.Create(params)

  // Publish template
  client.Templates.Publish(template.Id)
  ```

  ```rust Rust theme={null}
  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 Store <store@resend.com>";
    let subject = "Thanks for your order!";
    let html = "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>";

    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={null}
  Resend resend = new Resend("re_xxxxxxxxx");

  // Create template
  List<TemplateVariable> variables = Arrays.asList(
    new TemplateVariable("PRODUCT", "string", "item"),
    new TemplateVariable("PRICE", "number", 20),
  );

  CreateTemplateOptions params = CreateTemplateOptions.builder()
    .name("order-confirmation")
    .from("Resend Store <store@resend.com>")
    .subject("Thanks for your order!")
      .html("<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>")
    .variables(variables)
    .build();

  CreateTemplateResponseSuccess data = resend.templates().create(params);

  // Publish template
  resend.templates().publish(data.content);
  ```

  ```csharp .NET theme={null}
  using Resend;

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

  // Create template
  var variables = new List<TemplateVariable>
  {
    new TemplateVariable() {
      Key = "PRODUCT",
      Type = TemplateVariableType.String,
      Default = "item",
    },
    new TemplateVariable() {
      Key = "PRICE",
      Type = TemplateVariableType.Number,
      Default = 20,
    },
  };

  var resp = await resend.TemplateCreateAsync(
    new TemplateData()
    {
      Name = "order-confirmation",
      From = "Resend Store <store@resend.com>",
      Subject = "Thanks for your order!",
      HtmlBody = @"
        <p>Name: {{{PRODUCT}}}</p>
        <p>Total: {{{PRICE}}}</p>
      ",
      Variables = variables,
    }
  );

  // Publish template
  await resend.TemplatePublishAsync(resp.Content);

  Console.WriteLine($"Template Id={resp.Content}");
  ```

  ```bash cURL theme={null}
  # Create template
  curl -X POST 'https://api.resend.com/templates' \
   -H 'Authorization: Bearer re_xxxxxxxxx' \
   -H 'Content-Type: application/json' \
   -d $'{
    "name": "order-confirmation",
    "from": "Resend Store <store@resend.com>",
    "subject": "Thanks for your order!",
    "html": "<p>Name: {{{PRODUCT}}}</p><p>Total: {{{PRICE}}}</p>",
    "variables": [
      {
        "key": "PRODUCT",
        "type": "string",
        "fallbackValue": "item"
      },
      {
        "key": "PRICE",
        "type": "number",
        "fallbackValue": 20
      }
    ]
  }'

  # Publish template
  curl -X POST 'https://api.resend.com/templates/{template_id}/publish' \
       -H 'Authorization: Bearer re_xxxxxxxxx' \
       -H 'Content-Type: application/json'
  ```
</CodeGroup>

After you publish a template, you can freely work on it through the editor or [via the API](/api-reference/templates/update-template) without affecting the published version. This allows you to test and validate new edits before sending them to users.

## Version History

As you work on a Template, your changes are saved as a draft, although you can also manually save drafts by pressing <kbd>Cmd</kbd> + <kbd>S</kbd> (Mac) or <kbd>Ctrl</kbd> + <kbd>S</kbd> (Windows). Only after publishing again will the changes be reflected in emails using the Template.

Each template contains a version history that helps you track changes your team has made over time. You can view the version history by clicking the three dots in the top right corner of the template editor and selecting **Version History**.

Through the version history, you can preview each version, who made them, and when they were made. You can also revert to a previous version if needed.

<video />

Reverting creates a new draft based on the selected version's content, without affecting the published template.

## Iterating on a template

You can work on a new draft version of your published template, update the design and messaging, then test it thoroughly before publishing it again. Your email sending will continue to use the current published version until you're ready to make the switch, without the need to create a new separate template or risk leaking your new logo.

This behavior is also useful to avoid breaking changes when you need to edit a template that's in production. Add or remove variables, update the design, and more without affecting your existing emails or raising validation errors.


# Topics
Source: https://resend.com/docs/dashboard/topics/introduction

Give your users more control over their subscription preferences.

Managing subscribers and unsubscribers is a critical part of any email implementation. Topics are used by your contacts to manage their email preferences.

When you send [Broadcasts](/dashboard/broadcasts/introduction), you can optionally scope sending to a particular Topic. Not only does scoping your sending help you send more precisely, but it also allows your users to manage their preferences with more control.

<Note>
  Learn more about [customizing your team's unsubscribe
  page](/dashboard/settings/unsubscribe-page)
</Note>

## Add a Topic

You can create a new Topic from the [dashboard](https://resend.com/audience/topics) or [via the API](/api-reference/topics/create-topic).

1. Click **Create Topic**.
2. Give your Topic a name.
3. Give your Topic a description (optional).
4. Select **Opt-in** or **Opt-out** as the default subscription. This value **cannot** be changed later.
   * **Opt-in**: all Contacts will receive the email unless they have explicitly unsubscribed from that Topic.
   * **Opt-out**: subscribers will not receive the email unless they have explicitly subscribed to that Topic.
5. Select **Public** or **Private** as the visibility.
   * **Private**: only Contacts who are opted in to the Topic can see it on the unsubscribe page.
   * **Public**: all Contacts can see the Topic on the unsubscribe page.

<img alt="Add Topic" />

## View all Topics

The [dashboard](https://resend.com/audience/topics) shows you all the Topics you have created along with their details.

<img alt="View All Topics" />

You can also [retrieve a single Topic](/api-reference/topics/get-topic) or [list all your Topics](/api-reference/topics/list-topics) via the API.

## Edit Topic details

After creating a Topic, you can edit the following details:

* Name
* Description
* Visibility

To edit a Topic, click the **More options** <Icon icon="ellipsis" /> button and then **Edit Topic**.

<img alt="View edit topic" />

You can also [update a Topic](/api-reference/topics/update-topic) via the API.

<Info>
  You cannot edit the default subscription value after it has been created.
</Info>

## Delete a Topic

You can delete a Topic by clicking the **More options** <Icon icon="ellipsis" /> button and then **Remove Topic**.

<img alt="Delete Topic" />

You can also [delete a Topic](/api-reference/topics/delete-topic) via the API.

## Editing Topics for a Contact

As you receive [proper consent to email Contacts](/knowledge-base/what-counts-as-email-consent), add the Contact to a given Topic. A Contact can belong to multiple Topics.

You can add a Contact to a Topic via the dashboard by expanding the **More options** <Icon icon="ellipsis" /> and then **Edit Contact**. Add or remove Topics for a given Contact.

<img alt="Add Contact to Topic" />

<Note>
  The **Subscribed** status is a global setting that enables or disables sending to a Contact for Broadcasts.

  * If a Contact's **Subscribed** status is
    **false**, they will not receive emails from your account, even if they have
    opted-in to a specific Topic.

  * If the **Subscribed** status is **true**, they
    can receive emails from your account.

  Learn more about [managing your unsubscribe list](/dashboard/audiences/managing-unsubscribe-list).
</Note>

## Sending Broadcast with a Topic

You can send with a Topic in the Broadcast editor from the Topics dropdown menu.

<img alt="Send emails with a Topic" />

You can also send with a Topic via the [Broadcast API](/api-reference/broadcasts/create-broadcast).

## Unsubscribing from a Topic

If a Contact clicks a Broadcast unsubscribe link, they will see a preference page where they can:

* Unsubscribe from certain **Topics** (types of email)
* Or unsubscribe from **everything** you send

If they unsubscribe from a Topic or several Topics, they will no longer receive emails for those Topics. If they unsubscribe from all emails from your account, Broadcasts will no longer send to them.

You can [customize your unsubscribe page with your branding](/dashboard/settings/unsubscribe-page) from your team settings.

<img alt="See Topics on the Unsubscribe Page" />


# Examples
Source: https://resend.com/docs/examples

Explore sample apps for different use cases.

<CardGroup>
  <Card title="Attachments" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-attachments">
    Send emails with attachments
  </Card>

  <Card title="NextAuth" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-nextauth">
    Send emails with NextAuth
  </Card>

  <Card title="React Email" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-react-email">
    Send emails with React Email
  </Card>

  <Card title="Webhooks" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-webhooks">
    A Slack app using Resend webhooks
  </Card>

  <Card title="Prevent thread on Gmail" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-prevent-thread-on-gmail">
    Prevent threading on Gmail
  </Card>

  <Card title="Unsubscribe url header" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-unsubscribe-url-header">
    Add a shortcut for users to unsubscribe
  </Card>
</CardGroup>


# Integrations
Source: https://resend.com/docs/integrations

Integrate Resend with the tools you already use.

## AI

<CardGroup>
  <Card
    title="Lovable"
    href="https://docs.lovable.dev/integrations/resend"
    icon={
  <svg
    className="h-6 w-6"
    viewBox="0 0 78 69"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <path
      d="M38.768 69C37.9927 69 37.2119 68.8597 36.4255 68.5791C35.6398 68.2993 34.9562 67.8684 34.3747 67.2869L28.7204 62.0831C21.096 55.0378 14.4033 48.2348 8.64237 41.6741C2.88079 35.1136 0 28.1383 0 20.7484C0 14.8451 1.98137 9.91108 5.94412 5.94627C9.90752 1.98209 14.8181 0 20.676 0C24.0146 0 27.2669 0.770147 30.4329 2.31044C33.599 3.85139 36.3774 6.24845 38.768 9.50161C41.3739 6.24845 44.1953 3.85139 47.232 2.31044C50.2688 0.770147 53.4785 0 56.8602 0C62.7179 0 67.6288 1.98209 71.5921 5.94627C75.555 9.91108 77.5361 14.8451 77.5361 20.7484C77.5361 28.1383 74.6611 35.119 68.9103 41.6906C63.1595 48.2624 56.4504 55.0708 48.783 62.1161L43.1614 67.2869C42.5799 67.8684 41.8964 68.2993 41.1106 68.5791C40.3244 68.8597 39.5435 69 38.768 69Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Tell the Lovable AI to send emails
  </Card>

  <Card
    title="Anything"
    href="https://www.createanything.com/docs/integrations/resend"
    icon={
  <svg
    className="h-6 w-6"
    width="97"
    height="100"
    viewBox="0 0 97 100"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <path
      d="M84.2829 96.286C89.269 75.7132 93.7568 55.6139 93.9185 35.9376C94.0751 16.4376 89.7641 10.1999 86.5099 7.20085C85.8404 6.58277 85.1171 6.0387 84.3605 5.57696C81.7207 3.96559 78.5784 3.28239 74.752 3.48907C66.1585 3.95218 53.56 9.57643 38.3173 19.7567C22.4623 30.3451 9.05946 42.2082 5.33074 45.5938C5.22428 45.6911 5.05302 45.8388 4.84081 46.0254C4.19915 46.5866 3.64115 47.0877 3.18632 47.5108C3.05153 47.6337 3.04057 47.8407 3.16012 47.9948C3.1942 48.037 3.23208 48.0729 3.27877 48.1014C3.39396 48.1717 3.53522 48.1853 3.6595 48.1287C4.5571 47.7153 5.49911 47.222 6.41155 46.7492C7.44585 46.2097 8.50903 45.658 9.46801 45.235C17.3073 41.7862 27.6006 37.6006 37.6684 35.807C48.85 33.813 56.5565 34.586 62.6643 38.3142C67.8972 41.5084 71.49 45.0517 74.3123 49.8082C77.3625 54.9474 79.5651 61.6501 81.2392 70.9058C82.7572 79.2971 83.1466 87.8714 83.5238 96.1646C83.5291 96.296 83.6088 96.4172 83.7241 96.4875C83.7707 96.5161 83.8231 96.5352 83.8781 96.5432C84.0718 96.5759 84.2484 96.4615 84.2929 96.2836L84.2829 96.286Z"
      fill="currentColor"
    />
    <path
      d="M70.3756 85.1586C70.2252 76.2348 69.8684 55.336 58.319 48.2863C58.0762 48.1381 57.8234 47.9923 57.571 47.8597C52.0261 44.8895 44.5351 44.8206 35.2986 47.6601C27.9612 49.9154 21.6293 53.3656 18.9266 54.8394C18.4392 55.1058 18.0824 55.2983 17.8739 55.4018C17.71 55.4812 17.6417 55.6703 17.7104 55.8446C17.7442 55.9294 17.8069 56.0017 17.8815 56.0473C17.9562 56.093 18.0555 56.1193 18.1532 56.1063C18.264 56.0928 18.3791 56.0862 18.4993 56.0783C18.7083 56.0649 18.9205 56.0534 19.136 56.0012C36.5276 51.8627 45.3418 55.1962 51.0756 58.5638C51.1535 58.6113 51.2313 58.6588 51.3091 58.7062C60.6202 64.3898 67.0919 80.8639 69.2168 86.28C69.4137 86.7763 69.5671 87.1691 69.6771 87.437C69.7127 87.5186 69.7722 87.5891 69.8438 87.6328C69.9247 87.6822 70.0209 87.7067 70.1155 87.6918C70.2977 87.6663 70.4264 87.5184 70.4222 87.3363C70.4016 86.747 70.3885 86.0125 70.3736 85.1617L70.3756 85.1586Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Add email to your Anything projects
  </Card>

  <Card
    title="Wildcard"
    href="https://github.com/wild-card-ai/agents-json/blob/master/examples/resend.ipynb"
    icon={
  <svg
    className="h-6 w-6"
    width="64"
    height="64"
    viewBox="0 0 64 64"
    xmlns="http://www.w3.org/2000/svg"
  >
    <defs fill="currentColor" id="defs1" />
    <path
      d="m44,32l11.78,6.8-6,10.39-11.78-6.8v13.61h-12v-13.61l-11.78,6.8-6-10.39,11.78-6.8-11.78-6.8,6-10.39,11.78,6.8v-13.61h12v13.61l11.78-6.8,6,10.39-11.78,6.8Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send natural language emails using Wildcard
  </Card>

  <Card
    title="mcp.run"
    href="https://www.mcp.run/nilslice/resend"
    icon={
  <svg
    className="h-6 w-6"
    xmlns="http://www.w3.org/2000/svg"
    viewBox="0 0 570 126"
  >
    <g>
      <g>
        <g>
          <rect class="cls-2" x="0" y="0" width="18" height="18" />
          <rect class="cls-2" y="18" width="18" height="18" />
          <rect class="cls-2" x="0" y="36" width="18" height="18" />
          <rect class="cls-2" x="0" y="54" width="18" height="18" />
          <rect class="cls-2" y="72" width="18" height="18" />
          <rect class="cls-2" x="36" y="0" width="18" height="18" />
          <rect class="cls-2" x="36" y="18" width="18" height="18" />
          <rect class="cls-2" x="36" y="36" width="18" height="18" />
          <rect class="cls-2" x="36" y="54" width="18" height="18" />
          <rect class="cls-2" x="36" y="72" width="18" height="18" />
          <rect class="cls-2" x="72" y="0" width="18" height="18" />
          <rect class="cls-2" x="72" y="18" width="18" height="18" />
          <rect class="cls-2" x="72" y="36" width="18" height="18" />
          <rect class="cls-2" x="72" y="54" width="18" height="18" />
          <rect class="cls-2" x="72" y="72" width="18" height="18" />
          <polygon class="cls-2" points="11.12 18 36 18 36 0 11.12 18" />
          <polygon class="cls-2" points="47.12 18 72 18 72 0 47.12 18" />
        </g>
        <g>
          <rect
            class="cls-2"
            x="126"
            y="0"
            width="18"
            height="18"
            transform="translate(126 144) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="126"
            y="72"
            width="18"
            height="18"
            transform="translate(54 216) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="144"
            y="0"
            width="18"
            height="18"
            transform="translate(144 162) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="144"
            y="72"
            width="18"
            height="18"
            transform="translate(72 234) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="162"
            y="0"
            width="18"
            height="18"
            transform="translate(162 180) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="162"
            y="72"
            width="18"
            height="18"
            transform="translate(90 252) rotate(-90)"
          />
          <rect class="cls-2" x="99" y="18" width="18" height="18" />
          <rect class="cls-2" x="99" y="36" width="18" height="18" />
          <rect class="cls-2" x="99" y="54" width="18" height="18" />
          <polygon class="cls-2" points="99 18 126 18 126 0 99 18" />
          <polygon class="cls-2" points="99 72 126 72 126 90 99 72" />
        </g>
        <g>
          <rect
            class="cls-2"
            x="189"
            y="0"
            width="18"
            height="18"
            transform="translate(189 207) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="207"
            y="0"
            width="18"
            height="18"
            transform="translate(207 225) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="225"
            y="0"
            width="18"
            height="18"
            transform="translate(225 243) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="189"
            y="72"
            width="18"
            height="18"
            transform="translate(117 279) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="207"
            y="72"
            width="18"
            height="18"
            transform="translate(135 297) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="225"
            y="72"
            width="18"
            height="18"
            transform="translate(153 315) rotate(-90)"
          />
          <rect class="cls-2" x="189" y="18" width="18" height="18" />
          <rect class="cls-2" x="189" y="36" width="18" height="18" />
          <rect class="cls-2" x="189" y="54" width="18" height="18" />
          <rect class="cls-2" x="189" y="90" width="18" height="18" />
          <rect class="cls-2" x="189" y="108" width="18" height="18" />
          <rect class="cls-2" x="252" y="18" width="18" height="18" />
          <rect class="cls-2" x="252" y="36" width="18" height="18" />
          <rect class="cls-2" x="252" y="54" width="18" height="18" />
          <polygon class="cls-2" points="270 18 243 18 243 0 270 18" />
          <polygon class="cls-2" points="270 72 243 72 243 90 270 72" />
        </g>
        <g>
          <rect class="cls-2" x="552" y="18" width="18" height="18" />
          <rect class="cls-2" x="552" y="36" width="18" height="18" />
          <rect class="cls-2" x="489" y="18" width="18" height="18" />
          <rect class="cls-2" x="489" y="36" width="18" height="18" />
          <rect
            class="cls-2"
            x="552"
            y="0"
            width="18"
            height="18"
            transform="translate(570 -552) rotate(90)"
          />
          <rect
            class="cls-2"
            x="529.5"
            y="-4.5"
            width="18"
            height="27"
            transform="translate(547.5 -529.5) rotate(90)"
          />
          <rect
            class="cls-2"
            x="552"
            y="54"
            width="18"
            height="18"
            transform="translate(624 -498) rotate(90)"
          />
          <rect
            class="cls-2"
            x="507"
            y="0"
            width="18"
            height="18"
            transform="translate(525 -507) rotate(90)"
          />
          <rect
            class="cls-2"
            x="489"
            y="54"
            width="18"
            height="18"
            transform="translate(561 -435) rotate(90)"
          />
          <rect
            class="cls-2"
            x="552"
            y="72"
            width="18"
            height="18"
            transform="translate(642 -480) rotate(90)"
          />
          <rect
            class="cls-2"
            x="489"
            y="72"
            width="18"
            height="18"
            transform="translate(579 -417) rotate(90)"
          />
          <polygon class="cls-2" points="516 18 489 18 489 0 516 18" />
        </g>
        <g>
          <polygon class="cls-2" points="399 72 426 72 426 90 399 72" />
          <rect
            class="cls-2"
            x="399"
            y="54"
            width="18"
            height="18"
            transform="translate(816 126) rotate(180)"
          />
          <rect
            class="cls-2"
            x="399"
            y="36"
            width="18"
            height="18"
            transform="translate(816 90) rotate(180)"
          />
          <rect
            class="cls-2"
            x="462"
            y="54"
            width="18"
            height="18"
            transform="translate(942 126) rotate(180)"
          />
          <rect
            class="cls-2"
            x="462"
            y="36"
            width="18"
            height="18"
            transform="translate(942 90) rotate(180)"
          />
          <polygon
            class="cls-2"
            points="435 72 435 90 417 81 417 72 435 72"
          />
          <rect
            class="cls-2"
            x="430.5"
            y="67.5"
            width="18"
            height="27"
            transform="translate(358.5 520.5) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="399"
            y="18"
            width="18"
            height="18"
            transform="translate(381 435) rotate(-90)"
          />
          <polygon
            class="cls-2"
            points="462 72 462 81 444 90 444 72 462 72"
          />
          <rect
            class="cls-2"
            x="462"
            y="0"
            width="18"
            height="18"
            transform="translate(462 480) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="399"
            width="18"
            height="18"
            transform="translate(399 417) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="462"
            y="18"
            width="18"
            height="18"
            transform="translate(444 498) rotate(-90)"
          />
          <polygon class="cls-2" points="480 72 453 72 453 90 480 72" />
        </g>
        <g>
          <rect
            class="cls-2"
            x="336"
            y="0"
            width="18"
            height="18"
            transform="translate(336 354) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="354"
            y="0"
            width="18"
            height="18"
            transform="translate(354 372) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="372"
            y="0"
            width="18"
            height="18"
            transform="translate(372 390) rotate(-90)"
          />
          <rect
            class="cls-2"
            x="318"
            y="72"
            width="18"
            height="18"
            transform="translate(246 408) rotate(-90)"
          />
          <rect class="cls-2" x="318" y="18" width="18" height="18" />
          <rect class="cls-2" x="318" y="36" width="18" height="18" />
          <rect class="cls-2" x="318" y="54" width="18" height="18" />
          <polygon class="cls-2" points="345 18 318 18 318 0 345 18" />
        </g>
      </g>
      <rect
        class="cls-1"
        x="280.88"
        y="50.37"
        width="25.26"
        height="25.26"
        transform="translate(-6.32 77.77) rotate(-14.93)"
      />
    </g>
  </svg>
}
  >
    Build email AI agents using mcp.run
  </Card>

  <Card
    title="Rocket"
    href="https://docs.rocket.new/integrations/resend"
    icon={
  <svg
    width="121"
    className="h-6 w-6"
    height="127"
    viewBox="0 0 121 127"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <path
      d="M108.729 108.725L93.6186 94.4048C82.9086 84.2448 75.4986 71.1048 72.3386 56.6948L62.5386 12.1348C62.3086 11.1348 61.4786 10.6348 60.6486 10.6348C59.8186 10.6348 58.9986 11.1348 58.7586 12.1348L48.9586 56.7048C45.7886 71.1148 38.3886 84.2548 27.6786 94.4148L12.5686 108.735C11.1586 110.245 10.3686 112.235 10.3686 114.305V116.115L48.6886 109.495C52.6386 108.815 56.6486 108.465 60.6386 108.465C64.6286 108.465 68.6386 108.815 72.5886 109.495L110.909 116.115V114.305C110.909 112.235 110.119 110.245 108.709 108.735L108.729 108.725Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send emails from apps built with Rocket
  </Card>

  <Card
    title="Base44"
    href="https://docs.base44.com/Integrations/Resend-integration"
    icon={
  <svg
    width="159"
    className="h-6 w-6"
    height="159"
    viewBox="0 0 159 159"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <path
      d="M122.471 133.996C110.721 143.22 95.9081 148.721 79.8113 148.721C63.7148 148.721 48.903 143.22 37.1531 133.996H122.471ZM140.073 113.498C137.592 117.896 134.644 121.995 131.296 125.729H28.327C24.9786 121.995 22.0304 117.896 19.5496 113.498H140.073ZM147.648 93C146.817 97.2278 145.6 101.317 144.036 105.23H15.5867C14.0225 101.317 12.806 97.2278 11.9744 93H147.648ZM79.8113 10.4414C117.996 10.4414 148.951 41.3963 148.951 79.5811C148.951 81.3138 148.887 83.0317 148.762 84.7324H10.8621C10.7369 83.0316 10.6717 81.3138 10.6717 79.5811C10.6717 41.3963 41.6266 10.4415 79.8113 10.4414Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Add email to your Base44 apps
  </Card>

  <Card
    title="Leap.new"
    href="https://docs.leap.new/integrations/resend"
    icon={
  <svg
    width="24"
    height="24"
    viewBox="0 0 24 24"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <g clip-path="url(#clip0_1111_9)">
      <path
        d="M12.0515 12.0071V0.0585938H24V12.0071H12.0515ZM0.103027 23.9557V12.0071H12.0515V23.9557H0.103027Z"
        fill="currentColor"
      />
    </g>
    <defs>
      <clipPath id="clip0_1111_9">
        <rect width="24" height="24" fill="currentColor" />
      </clipPath>
    </defs>
  </svg>
}
  >
    Add email to your Leap apps
  </Card>

  <Card
    title="Pica"
    href="https://www.picaos.com/integrations/resend"
    icon={
  <svg
    className="h-6 w-6"
    width="81"
    height="81"
    viewBox="0 0 81 81"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <path
      fillRule="evenodd"
      clipRule="evenodd"
      d="M63.2164 31.6746C58.5597 31.6849 54.7765 35.4817 54.7663 40.1551C54.7559 44.8283 58.5225 48.6083 63.179 48.5979L77.8273 48.5655C79.3265 48.5622 80.5428 49.7828 80.5395 51.2874C80.5361 52.7821 79.3296 53.9928 77.8402 53.9961L66.9424 54.0203C60.2703 54.035 54.8496 59.4753 54.8348 66.1712L54.8092 77.8042C54.8056 79.4728 53.4588 80.8243 51.7962 80.828C50.1228 80.8318 48.7651 79.4692 48.7688 77.7898L48.8013 63.0273C48.8116 58.354 45.0451 54.5739 40.3884 54.5843C35.7319 54.5945 31.9487 58.3914 31.9383 63.0647L31.9056 77.9806C31.902 79.5797 30.6115 80.8749 29.0181 80.8785C27.4144 80.8821 26.1134 79.5763 26.1168 77.9668L26.1427 66.2348C26.1573 59.5389 20.7605 54.1227 14.0884 54.1374L2.71207 54.1626C1.21295 54.1659 -0.0033077 52.9453 6.7582e-06 51.4409C0.00329407 49.9461 1.20973 48.7353 2.69914 48.732L17.624 48.699C22.2805 48.6886 26.0638 44.8918 26.074 40.2186C26.0844 35.5453 22.3178 31.7652 17.6611 31.7756L3.01408 31.808C1.37551 31.8116 0.0461153 30.4774 0.0497358 28.8331C0.0533261 27.1992 1.372 25.8759 2.99995 25.8723L14.1506 25.8476C20.8228 25.8328 26.2435 20.3926 26.2583 13.6966L26.2818 2.94826C26.2854 1.34923 27.5759 0.054002 29.1693 0.0504723C30.7731 0.0469191 32.0741 1.35269 32.0706 2.96214L32.039 17.3462C32.0287 22.0196 35.7952 25.7996 40.4517 25.7892C45.1084 25.779 48.8916 21.9822 48.9018 17.3089L48.9333 3.02378C48.937 1.35524 50.2837 0.00369132 51.9463 7.55018e-06C53.6197 -0.00370043 54.9774 1.35884 54.9737 3.03827L54.9504 13.633C54.9357 20.3291 60.3326 25.7453 67.0046 25.7304L77.6248 25.7069C79.2633 25.7033 80.5927 27.0374 80.5891 28.6819C80.5856 30.3157 79.2669 31.6391 77.6389 31.6427L63.2164 31.6746ZM48.851 40.4207C48.8615 35.6777 45.0388 31.8412 40.3126 31.8517C35.5866 31.8621 31.7469 35.7156 31.7364 40.4586C31.7259 45.2016 35.5488 49.0381 40.2748 49.0276C45.0009 49.0172 48.8406 45.1637 48.851 40.4207Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Integrate Pica with Resend
  </Card>
</CardGroup>

## No-code

<CardGroup>
  <Card
    title="Zapier"
    href="https://zapier.com/apps/resend/integrations"
    icon={
  <svg className="h-6 w-6" width="68" height="68" viewBox="0 0 256 256">
    <title>Zapier</title>
    <g>
      <path
        d="M128.080089,-0.000183105 C135.311053,0.0131003068 142.422517,0.624138494 149.335663,1.77979593 L149.335663,1.77979593 L149.335663,76.2997796 L202.166953,23.6044907 C208.002065,27.7488446 213.460883,32.3582023 218.507811,37.3926715 C223.557281,42.4271407 228.192318,47.8867213 232.346817,53.7047992 L232.346817,53.7047992 L179.512985,106.400063 L254.227854,106.400063 C255.387249,113.29414 256,120.36111 256,127.587243 L256,127.587243 L256,127.759881 C256,134.986013 255.387249,142.066204 254.227854,148.960282 L254.227854,148.960282 L179.500273,148.960282 L232.346817,201.642324 C228.192318,207.460402 223.557281,212.919983 218.523066,217.954452 L218.523066,217.954452 L218.507811,217.954452 C213.460883,222.988921 208.002065,227.6115 202.182208,231.742607 L202.182208,231.742607 L149.335663,179.04709 L149.335663,253.5672 C142.435229,254.723036 135.323765,255.333244 128.092802,255.348499 L128.092802,255.348499 L127.907197,255.348499 C120.673691,255.333244 113.590195,254.723036 106.677048,253.5672 L106.677048,253.5672 L106.677048,179.04709 L53.8457596,231.742607 C42.1780766,223.466917 31.977435,213.278734 23.6658953,201.642324 L23.6658953,201.642324 L76.4997269,148.960282 L1.78485803,148.960282 C0.612750404,142.052729 0,134.946095 0,127.719963 L0,127.719963 L0,127.349037 C0.0121454869,125.473817 0.134939797,123.182933 0.311311815,120.812834 L0.36577283,120.099764 C0.887996182,113.428547 1.78485803,106.400063 1.78485803,106.400063 L1.78485803,106.400063 L76.4997269,106.400063 L23.6658953,53.7047992 C27.8076812,47.8867213 32.4300059,42.4403618 37.4769335,37.4193681 L37.4769335,37.4193681 L37.5023588,37.3926715 C42.5391163,32.3582023 48.0106469,27.7488446 53.8457596,23.6044907 L53.8457596,23.6044907 L106.677048,76.2997796 L106.677048,1.77979593 C113.590195,0.624138494 120.688946,0.0131003068 127.932622,-0.000183105 L127.932622,-0.000183105 L128.080089,-0.000183105 Z M128.067377,95.7600714 L127.945335,95.7600714 C118.436262,95.7600714 109.32891,97.5001809 100.910584,100.661566 C97.7553011,109.043534 96.0085811,118.129275 95.9958684,127.613685 L95.9958684,127.733184 C96.0085811,137.217594 97.7553011,146.303589 100.923296,154.685303 C109.32891,157.846943 118.436262,159.587052 127.945335,159.587052 L128.067377,159.587052 C137.576449,159.587052 146.683802,157.846943 155.089415,154.685303 C158.257411,146.290368 160.004131,137.217594 160.004131,127.733184 L160.004131,127.613685 C160.004131,118.129275 158.257411,109.043534 155.089415,100.661566 C146.683802,97.5001809 137.576449,95.7600714 128.067377,95.7600714 Z"
        fill="currentColor"
        fillRule="currentColor"
      />
    </g>
  </svg>
}
  >
    Automate emails using Zapier
  </Card>

  <Card
    title="Pipedream"
    href="https://pipedream.com/apps/resend"
    icon={
  <svg
    className="h-6 w-6"
    width="78"
    height="78"
    viewBox="0 0 78 78"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Pipedream</title>
    <path
      d="M47.7519 30.1241C48.0541 31.7495 48.2068 33.8016 48.2068 36.2869C48.2068 39.0588 48.0096 41.316 47.6119 43.0587C47.2142 44.8013 46.667 46.1661 45.9671 47.1433C45.2672 48.1237 44.4273 48.7914 43.4475 49.1497C42.3892 49.5211 41.2764 49.7029 40.1579 49.6872C38.4304 49.6872 36.9861 49.3289 35.8185 48.6123C34.6509 47.8957 33.741 47.013 33.0888 45.9609V27.3294C33.881 26.2317 34.8959 25.3685 36.1334 24.7497C37.4558 24.1088 38.9051 23.7899 40.3679 23.8181C41.5671 23.7939 42.7618 23.9756 43.9024 24.3555C44.9024 24.7112 45.7623 25.3903 46.3521 26.2903C46.982 27.2219 47.4497 28.4988 47.7519 30.1241Z"
      fill="currentColor"
    />
    <path
      fillRule="evenodd"
      clipRule="evenodd"
      d="M1.61933 8.11214C0 11.2903 0 15.4506 0 23.7714V54.2286C0 62.5493 0 66.7097 1.61933 69.8879C3.04374 72.6834 5.31659 74.9563 8.11214 76.3807C11.2903 78 15.4506 78 23.7714 78H54.2286C62.5493 78 66.7097 78 69.8879 76.3807C72.6834 74.9563 74.9563 72.6834 76.3807 69.8879C78 66.7097 78 62.5493 78 54.2286V23.7714C78 15.4506 78 11.2903 76.3807 8.11214C74.9563 5.31659 72.6834 3.04374 69.8879 1.61933C66.7097 0 62.5493 0 54.2286 0H23.7714C15.4506 0 11.2903 0 8.11214 1.61933C5.31659 3.04374 3.04374 5.31659 1.61933 8.11214ZM58.2855 46.3192C59.0776 43.5017 59.4753 40.1793 59.4753 36.3585C59.4753 32.2023 59.1254 28.6909 58.4255 25.8246C57.7256 22.9582 56.6884 20.652 55.3109 18.9094C53.9333 17.1635 52.2408 15.8997 50.2366 15.1115C48.2291 14.3232 45.9194 13.9291 43.3075 13.9291C41.1569 13.9128 39.0217 14.3014 37.0083 15.0756C35.0995 15.8082 33.3425 16.9021 31.829 18.3003L29.7293 14.5024L22.1003 15.004V69.1786H33.0888V61.2244L32.9489 55.4199L33.1588 55.3483C34.5109 56.7326 36.0189 57.6642 37.6732 58.143C39.4174 58.6327 41.2191 58.8738 43.0275 58.8596C45.4995 58.8596 47.7519 58.4068 49.7816 57.4981C51.8113 56.5893 53.5388 55.205 54.9609 53.3418C56.383 51.4787 57.4901 49.1367 58.2855 46.3192Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Build workflows using Pipedream
  </Card>

  <Card
    title="Activepieces"
    href="https://www.activepieces.com/pieces/resend"
    icon={
  <svg
    className="h-6 w-6"
    width="56"
    height="50"
    viewBox="0 0 56 50"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Activepieces</title>
    <path
      d="M17.3113 15.3098C14.2791 10.8144 15.4653 4.7122 19.9607 1.68001C24.456 -1.35215 30.5583 -0.165992 33.5904 4.3294L54.0697 34.6911C57.1018 39.1864 55.9157 45.2887 51.4203 48.3209C46.9249 51.353 40.8227 50.1669 37.7905 45.6715L28.9117 32.5081C27.7703 31.0698 25.4468 31.2937 24.0517 32.6888C22.8948 33.8457 22.516 36.8053 22.1881 39.3679C22.14 39.7436 22.093 40.1108 22.0448 40.4625C21.8669 42.1398 21.2877 43.7992 20.2789 45.2948C16.9823 50.1823 10.346 51.4707 5.4586 48.1741C0.571158 44.8775 -0.720183 38.2418 2.57644 33.3544C4.28615 30.8197 6.89414 29.2529 9.69057 28.7918L9.68663 28.7878C17.7665 27.6159 19.2645 18.4973 17.7858 16.0133L17.3113 15.3098Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Build workflows using Activepieces
  </Card>

  <Card
    title="Monkedo"
    href="https://monkedo.com/integrations/app/resend"
    icon={
<svg
    className="h-6 w-6"
    width="70"
    height="70"
    viewBox="0 0 300 300"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
  <title>Monkedo</title>
<path id="Selection"
    fill="currentColor"
    d="M 155.00,254.00
       C 130.11,254.00 106.02,248.09 83.00,238.80
         76.96,236.36 60.67,229.07 56.00,225.47
         45.10,217.07 46.03,210.07 40.79,205.42
         40.79,205.42 25.00,197.53 25.00,197.53
         16.15,192.04 10.40,182.12 8.46,172.00
         5.59,157.09 9.59,142.41 22.00,132.90
         31.50,125.62 34.73,127.48 38.30,122.87
         38.30,122.87 44.26,110.00 44.26,110.00
         47.64,103.06 52.39,95.99 57.26,90.00
         79.24,62.94 109.53,48.32 144.00,45.91
         144.00,45.91 156.00,45.01 156.00,45.01
         184.47,45.66 213.18,58.56 232.96,79.00
         232.96,79.00 254.04,105.77 254.04,105.77
         259.66,110.61 263.92,108.01 272.00,111.99
         284.97,118.39 291.62,132.07 292.68,146.00
         293.42,155.73 286.99,170.24 279.96,176.83
         279.96,176.83 267.70,186.21 267.70,186.21
         264.36,190.49 264.91,200.02 258.54,211.00
         255.42,216.37 250.59,222.69 246.00,226.83
         236.44,235.44 214.56,245.62 202.00,249.00
         206.82,243.15 212.17,239.55 215.47,232.00
         217.99,226.23 217.53,219.24 219.17,216.00
         221.75,210.93 228.79,207.78 233.01,201.00
         237.57,193.66 239.19,176.84 239.82,168.00
         240.11,163.85 238.61,155.08 237.41,151.00
         230.85,128.72 213.47,115.38 190.00,120.66
         183.84,122.05 177.23,124.84 172.00,128.36
         169.07,130.33 164.14,135.17 161.00,135.48
         157.70,135.79 148.45,130.39 145.00,128.78
         137.64,125.34 124.96,122.77 117.00,124.93
         97.13,130.30 82.56,154.01 83.01,174.00
         83.24,183.73 87.95,196.78 93.06,205.00
         96.24,210.10 101.12,215.87 106.00,219.37
         109.65,221.98 113.42,222.92 116.89,226.21
         122.67,231.69 120.74,236.83 130.00,244.79
         139.84,253.24 149.23,251.68 155.00,254.00 Z
       M 259.00,161.00
       C 256.67,161.61 254.41,162.04 253.02,164.27
         251.15,167.28 252.14,172.90 256.11,173.58
         260.96,174.41 267.84,168.49 270.61,165.00
         279.10,154.30 278.11,134.86 265.99,127.14
         258.29,122.24 243.87,123.88 245.98,132.00
         248.00,139.80 252.88,136.77 258.00,138.74
         263.60,140.89 269.57,149.89 268.43,156.00
         267.64,160.19 260.70,171.33 259.00,161.00 Z
       M 41.00,142.30
       C 32.91,143.88 29.22,146.35 25.74,154.00
         18.25,170.42 29.20,191.14 48.00,191.96
         62.66,192.60 64.03,182.57 65.28,171.00
         67.08,154.40 59.52,140.51 41.00,142.30 Z" />
</svg>
}
  >
    Automate emails using Monkedo
  </Card>

  <Card
    title="Make.com"
    href="https://www.make.com/en/integrations/resend"
    icon={
  <svg className="h-6 w-6" width="46" height="46" viewBox="0 0 46 46" fill="none" xmlns="http://www.w3.org/2000/svg">
    <title>Make.com</title>
    <rect x="34" y="8" width="9" height="28" rx="0.75" fill="currentColor"/>
    <rect x="24.8215" y="8" width="9" height="28" rx="0.75" transform="rotate(12 24.8215 8)" fill="currentColor"/>
    <rect x="15.1452" y="8" width="9" height="28" rx="0.75" transform="rotate(28 15.1452 8)" fill="currentColor"/>
  </svg>
}
  >
    Build workflows using Make.com
  </Card>

  <Card
    title="Lindy"
    href="https://www.lindy.ai/integrations/resend"
    icon={
  <svg className="h-6 w-6" width="22" height="22" viewBox="0 0 22 22" fill="none" xmlns="http://www.w3.org/2000/svg">
    <title>Lindy</title>
    <path d="M10.8029 1.11017L9.10941 2.81543C8.96353 2.96232 8.96353 3.20182 9.10941 3.35192L16.4382 10.7318C16.584 10.8787 16.584 11.1182 16.4382 11.2683L9.10941 18.6481C8.96353 18.795 8.96353 19.0345 9.10941 19.1846L10.8029 20.8899C10.9487 21.0367 11.1866 21.0367 11.3356 20.8899L20.8906 11.2683C21.0365 11.1214 21.0365 10.8819 20.8906 10.7318L11.3356 1.11017C11.1898 0.963276 10.9519 0.963276 10.8029 1.11017Z" fill="currentColor"/>
    <path d="M5.78281 10.2325L9.88188 6.33183C10.0349 6.18619 10.0349 5.94874 9.88188 5.79993L8.10517 4.10923C7.95213 3.96359 7.70259 3.96359 7.54621 4.10923L1.11479 10.2325C0.961738 10.3781 0.961738 10.6156 1.11479 10.7644L7.54954 16.8907C7.70259 17.0364 7.95213 17.0364 8.1085 16.8907L9.88521 15.2001C10.0383 15.0544 10.0383 14.817 9.88521 14.6681L5.78281 10.7644C5.62976 10.6187 5.62976 10.3813 5.78281 10.2325Z" fill="currentColor"/>
  </svg>
}
  >
    Build workflows using Lindy
  </Card>

  <Card
    title="BuildShip"
    href="https://buildship.com/integrations/resend"
    icon={
  <svg className="h-6 w-6" width="106" height="149" viewBox="0 0 106 149" fill="none" xmlns="http://www.w3.org/2000/svg">
    <path fillRule="evenodd" clipRule="evenodd" d="M31.9923 104.997C19.6877 104.938 15.5862 101.925 9.58646 95.9192C-2.90892 83.4342 -3.22369 63.4663 8.87108 51.3752C14.6037 45.6447 22.4156 42.4644 30.6282 42.4939H41.1301V29.9992H41.1492C41.6929 13.3396 55.8003 -0.00195312 73.1317 -0.00195312C90.7874 -0.00195312 105.133 13.891 105.133 31.0036C105.133 48.126 90.7874 62.462 73.1126 62.462L61.1322 62.4915V84.9998H72.1301C89.2516 84.9998 103.13 99.326 103.13 117C103.13 134.664 89.2421 149 72.1301 149C55.991 149 42.5513 136.259 41.0824 119.983L41.1301 104.997C41.1301 104.997 35.0446 105.086 31.9923 104.997ZM31.315 62.4915L31.3245 62.5407C28.2818 62.4915 25.3917 63.6533 23.2741 65.7703C18.8674 70.1715 18.9914 77.4282 23.5317 81.9771C25.6969 84.1432 28.5298 85.0589 31.5534 85.118L41.1301 84.9998V62.4915H31.315ZM61.1322 31.0036V42.4939L73.1412 42.4743C79.5702 42.4743 84.7686 37.2263 84.7686 31.0036C84.7686 24.7808 79.5511 19.7198 73.1317 19.7198C66.7028 19.7198 61.1322 24.771 61.1322 31.0036ZM72.2064 105.056L61.1322 104.997V119.57C62.2673 124.759 66.7599 128.638 72.1301 128.638C78.3587 128.638 83.4045 123.429 83.4045 117C83.4045 110.57 78.435 105.056 72.2064 105.056Z" fill="currentColor"/>
</svg>
}
  >
    Build workflows using BuildShip
  </Card>

  <Card
    title="viaSocket"
    href="https://viasocket.com/integrations/resend"
    icon={
 <svg class="h-6 w-6" width="32" height="32" viewBox="128 128 300 300" fill="none" xmlns="http://www.w3.org/2000/svg"><path id="Selection"
    fill="currentColor"
    d="M 397.00,409.89
       C 396.84,411.94 396.90,413.90 395.40,415.40
         390.55,420.26 375.32,413.65 371.33,409.67
         371.33,409.67 365.62,402.60 365.62,402.60
         363.57,400.98 361.47,401.05 359.00,401.00
         359.00,401.00 223.00,401.00 223.00,401.00
         223.00,401.00 192.00,401.00 192.00,401.00
         188.86,400.95 185.82,400.96 183.43,398.57
         180.64,395.78 181.01,391.62 181.00,388.00
         181.00,388.00 181.00,228.00 181.00,228.00
         181.00,228.00 181.00,194.00 181.00,194.00
         181.01,190.74 180.71,186.98 182.74,184.21
         185.93,179.87 191.19,180.01 196.00,180.00
         196.00,180.00 365.00,180.00 365.00,180.00
         365.00,180.00 401.00,180.00 401.00,180.00
         405.00,180.01 409.52,179.73 412.77,182.51
         416.37,185.58 415.99,189.73 416.00,194.00
         416.00,194.00 416.00,321.00 416.00,321.00
         415.99,324.19 416.29,328.09 414.26,330.77
         411.04,335.05 403.46,335.27 400.17,328.98
         398.79,326.34 399.00,322.91 399.00,320.00
         399.00,320.00 399.00,198.00 399.00,198.00
         399.00,198.00 198.00,198.00 198.00,198.00
         198.00,198.00 198.00,384.00 198.00,384.00
         198.00,384.00 305.00,384.00 305.00,384.00
         305.00,384.00 359.00,384.00 359.00,384.00
         361.50,383.95 363.55,384.02 365.63,382.40
         365.63,382.40 372.04,375.10 372.04,375.10
         376.12,371.22 390.25,364.74 395.26,369.74
         396.75,371.22 396.77,373.08 397.00,375.00
         400.73,375.00 412.11,374.58 414.96,375.74
         417.36,376.72 419.67,379.06 418.60,381.86
         416.77,386.64 401.53,385.00 397.00,385.00
         397.00,385.00 397.00,400.07 397.00,400.07
         397.00,400.07 413.98,400.07 413.98,400.07
         416.60,400.56 419.14,401.97 419.14,404.98
         419.14,407.91 416.51,409.30 413.98,409.89
         413.98,409.89 397.00,409.89 397.00,409.89 Z
       M 257.00,236.56
       C 278.40,236.00 275.68,266.44 257.00,264.15
         242.05,262.32 238.93,240.39 257.00,236.56 Z
       M 340.00,236.64
       C 359.92,236.95 358.53,262.96 342.00,264.36
         331.15,265.28 323.80,253.49 328.69,244.02
         331.22,239.09 334.83,237.55 340.00,236.64 Z
       M 270.04,311.74
       C 276.05,310.26 295.44,313.01 304.00,313.00
         304.00,313.00 329.00,311.43 329.00,311.43
         337.08,313.66 338.57,325.00 329.00,328.86
         324.67,330.60 318.61,330.71 314.00,331.17
         302.01,332.37 285.79,331.96 274.00,329.54
         263.08,327.29 262.18,316.32 270.04,311.74 Z
       M 387.00,379.00
       C 373.52,380.44 371.64,393.77 376.72,400.90
         379.24,404.42 383.12,405.64 387.00,407.00
         387.00,407.00 387.00,379.00 387.00,379.00 Z" />
</svg>

}
  >
    Build automations using viaSocket
  </Card>

  <Card
    title="Stacksync"
    href="https://www.stacksync.com/connectors/resend"
    icon={
 <svg className="h-6 w-6" width="60" height="60" viewBox="0 0 60 60" fill="none" xmlns="http://www.w3.org/2000/svg">
<path d="M29.6451 2.01246C29.8747 1.88009 30.1438 1.89179 30.354 2.01637L55.69 16.6511C56.0285 16.8457 56.1459 17.2782 55.9517 17.613C55.8855 17.726 55.795 17.8154 55.69 17.8738L45.7193 23.6316L55.7046 29.3982C56.043 29.5928 56.1558 30.0252 55.9615 30.364C55.8953 30.4767 55.8056 30.5624 55.7007 30.6248L45.7447 36.3738L55.6939 42.1209C56.0326 42.3156 56.146 42.748 55.9517 43.0867C55.8778 43.2111 55.7763 43.3047 55.6558 43.367L30.3462 57.9861C30.1166 58.1184 29.8475 58.1066 29.6372 57.9822L4.30131 43.3435C3.96271 43.1488 3.84499 42.7164 4.03959 42.3816C4.10575 42.2687 4.19625 42.1831 4.29741 42.1248L14.2554 36.3709L4.29545 30.6091C3.95691 30.4144 3.84416 29.983 4.03862 29.6443C4.10478 29.5314 4.19427 29.445 4.29936 29.3826L14.2622 23.6287L18.9722 26.3503L12.6509 29.9978L20.147 34.3269L20.2017 34.3621H20.2056L29.9976 40.0193L36.3189 36.3679L4.30131 17.8738C3.9629 17.6793 3.84544 17.2476 4.03959 16.9128C4.10576 16.7999 4.19623 16.7095 4.30131 16.6511L29.6451 2.01246ZM12.6451 42.7322L29.9956 52.7537L47.3423 42.7361L41.0328 39.0916L30.356 45.2595C30.1264 45.392 29.8572 45.3802 29.647 45.2556L28.8335 44.7888L18.9585 39.0847L12.6451 42.7322ZM23.6861 23.6336L41.022 33.6462L47.3404 30.0017L39.8443 25.6726C39.821 25.6608 39.7972 25.6452 39.7779 25.6296L30.0015 19.9851L23.6861 23.6336ZM12.649 17.2586L18.9849 20.9177L29.647 14.7605C29.8884 14.6203 30.1771 14.639 30.3951 14.783L41.0103 20.9158L47.3501 17.2546L29.9956 7.23805L12.649 17.2586Z" fill="currentColor"/>
</svg>

}
  >
    Build automations using Stacksync
  </Card>

  <Card href="https://apix-drive.com/en/integrations/resend" icon={<svg xmlns="http://www.w3.org/2000/svg" width="80" fill="none" viewBox="0 0 174 46"><title>ApiX-Drive</title><path fill="currentColor" d="M18.077 29.276H7.714L5.737 34.07H.443l9.95-22.369h5.101l9.98 22.369h-5.42zm-1.626-3.93-3.54-8.564-3.54 8.564zM47.158 19.818c0 4.984-3.73 8.084-9.693 8.084h-4.497v6.168h-5.165V11.7h9.662c5.962 0 9.693 3.1 9.693 8.117m-5.23 0c0-2.461-1.593-3.899-4.75-3.899h-4.21v7.765h4.21c3.157 0 4.75-1.438 4.75-3.866M50.826 11.701h5.166V34.07h-5.166zM89.293 11.701h10.14c7.302 0 12.309 4.41 12.309 11.184 0 6.775-5.007 11.184-12.309 11.184h-10.14zm9.884 18.118c4.433 0 7.335-2.652 7.335-6.934s-2.902-6.935-7.335-6.935H94.46v13.87zM125.932 16.621v4.601c-.415-.031-.734-.064-1.116-.064-2.742 0-4.56 1.503-4.56 4.794v8.117h-4.975V16.877h4.752v2.269c1.211-1.662 3.252-2.525 5.899-2.525M128.291 11.701c0-1.565 1.244-2.78 3.093-2.78s3.093 1.15 3.093 2.684c0 1.662-1.244 2.876-3.093 2.876s-3.093-1.214-3.093-2.78m.606 5.176h4.974V34.07h-4.974zM155.524 16.877l-7.239 17.192h-5.133l-7.207-17.192h5.134l4.751 11.696 4.911-11.696zM173.793 26.88h-12.978c.478 2.14 2.296 3.45 4.911 3.45 1.817 0 3.125-.543 4.305-1.661l2.646 2.875c-1.594 1.821-3.986 2.78-7.079 2.78-5.931 0-9.789-3.738-9.789-8.851 0-5.145 3.922-8.852 9.151-8.852 5.038 0 8.929 3.388 8.929 8.916 0 .383-.064.926-.096 1.342m-13.042-2.909h8.45c-.35-2.173-1.977-3.58-4.209-3.58-2.263 0-3.89 1.375-4.241 3.58"/><path fill="currentColor" d="m59.475 37.86 10.687-15.358-7.78-10.8h5.58L73 18.956 84.564 2.66h5.867L76.157 22.693l8.258 11.377h-5.93l-5.293-7.766-11.807 16.262zM58.898 43.092l-1.86-4.733H.444l2.12 4.733z"/></svg>}>
    Use Resend as a data destination in ApiX-Drive
  </Card>

  <Card
    title="Post SMTP"
    href="https://postmansmtp.com/docs/mailers/how-to-setup-resend-with-post-smtp/"
    icon={
  <svg className="h-6 w-6" width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
    <title>Post SMTP</title>
    <path d="M22.0791 0.550279C22.5059 0.345735 23 0.656784 23 1.12938V19.9194C23 20.3882 22.5145 20.6988 22.0889 20.5044L14.0635 16.8296L14.0615 16.8306L14.0645 16.8315L12.9854 18.1802L8.72754 23.5151L10.1582 16.687C10.1672 16.645 10.1812 16.6043 10.1982 16.5649L10.1895 16.5425L10.207 16.5434C10.2271 16.5014 10.2517 16.4614 10.2803 16.4243L17.0088 7.79442C17.5018 7.16173 16.6225 6.37808 16.0508 6.9409L9.68555 13.1977C9.5128 13.3677 9.26008 13.4265 9.03027 13.3491L1.4668 10.8081C1.29556 10.7508 1.28188 10.5145 1.44434 10.437L22.0791 0.550279ZM5.47168 17.103C5.61905 16.9239 5.88473 16.8974 6.06641 17.0434C6.24679 17.1908 6.27329 17.4558 6.12598 17.6362L1.46094 23.3335C1.44064 23.3575 1.41764 23.3789 1.39355 23.3979C1.15743 23.2569 1 23.0001 1 22.7056V22.5649L5.47168 17.103ZM5.14844 21.3931C5.29835 21.2139 5.56403 21.1914 5.74316 21.3413C5.9223 21.4912 5.94582 21.7568 5.7959 21.936L5.23828 22.6001C5.1557 22.6992 5.03808 22.7502 4.91992 22.7515C4.82222 22.7527 4.72478 22.7203 4.64355 22.6518C4.46442 22.5019 4.44091 22.2363 4.59082 22.0571L5.14844 21.3931ZM8.34863 17.2817C8.49218 17.0991 8.75756 17.0671 8.94043 17.2104C9.12337 17.354 9.15528 17.6203 9.01172 17.8032L6.55566 20.9321C6.47818 21.0298 6.36525 21.0846 6.25098 21.0923C6.15068 21.0986 6.04895 21.0694 5.96387 21.0034C5.78102 20.86 5.74931 20.5945 5.89258 20.4116L8.34863 17.2817ZM4.23047 14.7436C4.37268 14.5596 4.63809 14.5255 4.82227 14.6675C5.00648 14.8098 5.0417 15.0747 4.89941 15.2602L2.39844 18.3843C2.32095 18.4831 2.20755 18.5388 2.09082 18.5464C1.99193 18.5527 1.89162 18.525 1.80664 18.4604C1.62243 18.3182 1.58817 18.0532 1.73047 17.8677L4.23047 14.7436Z" fill="currentColor"/>
  </svg>
}
  >
    Send emails from WordPress with Post SMTP
  </Card>
</CardGroup>

## Notifications

<CardGroup>
  <Card
    title="Courier"
    href="https://www.courier.com/docs/guides/providers/email/resend/"
    icon={
  <svg
    className="h-6 w-6"
    width="68"
    height="68"
    viewBox="0 0 68 68"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Courier</title>
    <path
      d="M63.5245 30.6744C63.6695 30.4568 63.7421 30.1668 63.7421 29.9492C61.1315 14.8658 47.9335 3.40823 32.125 3.40823C14.3585 3.40823 -0.0722441 17.9115 0.00027211 35.7505C0.145305 53.0819 14.7211 67.5851 31.9799 67.5851C46.7007 67.6576 59.101 57.7954 62.9444 44.3799C63.0894 43.9448 62.7993 43.4372 62.3642 43.2197L61.059 42.712C55.9103 40.8991 50.1815 41.5518 45.613 44.525C43.51 45.9028 41.9872 46.9905 41.9872 46.9905C39.3766 48.7309 36.1859 49.8186 32.8501 49.8186C23.7856 49.8186 17.4767 42.422 16.4615 33.43L15.7363 28.4989C15.5188 26.976 14.5035 25.7432 13.0532 25.1631L11.2403 24.4379C10.9502 24.2929 10.8052 23.9303 11.0228 23.6403C18.782 13.2705 28.2816 15.5185 28.2816 15.5185C29.9495 15.6635 31.3998 16.3161 32.5601 17.1138C34.2279 18.2741 35.5332 19.942 36.3309 21.8274C39.2316 28.4989 45.9031 33.2124 53.6623 33.2124C53.6623 33.2124 61.059 33.5025 63.5245 30.6744Z"
      fill="currentColor"
    />
    <path
      d="M19.7247 22.9151C20.766 22.9151 21.6101 22.071 21.6101 21.0297C21.6101 19.9884 20.766 19.1443 19.7247 19.1443C18.6834 19.1443 17.8393 19.9884 17.8393 21.0297C17.8393 22.071 18.6834 22.9151 19.7247 22.9151Z"
      fill="currentColor"
    />
    <path
      d="M20.0873 32.7048C20.5224 35.6054 22.8429 44.8875 33.1402 46.5554C33.2852 46.5554 33.3578 46.3379 33.2127 46.2653C30.8197 45.1776 24.5833 41.5518 20.3773 32.5598C20.3048 32.4872 20.0873 32.5598 20.0873 32.7048Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Trigger messages using Courier
  </Card>

  <Card
    title="Novu"
    href="https://docs.novu.co/platform/integrations/email/resend"
    icon={
  <svg
    viewBox="0 0 102 32"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
    className="h-6"
  >
    <title>Novu</title>
    <path
      fillRule="evenodd"
      clipRule="evenodd"
      d="M24.64 12.826c0 .86-1.044 1.286-1.646.671L10.676.907A15.974 15.974 0 0 1 16 0c3.183 0 6.148.93 8.64 2.531v10.295Zm4.48-5.986v5.986c0 4.875-5.919 7.289-9.328 3.804L6.545 3.091C2.576 6.003 0 10.701 0 16c0 3.407 1.065 6.565 2.88 9.16v-5.954c0-4.875 5.919-7.289 9.328-3.804l13.229 13.52C29.416 26.012 32 21.308 32 16c0-3.407-1.065-6.565-2.88-9.16ZM9.006 18.535 21.301 31.1C19.642 31.683 17.858 32 16 32c-3.182 0-6.148-.93-8.64-2.531V19.206c0-.86 1.045-1.286 1.646-.671Z"
      fill="currentColor"
    ></path>
    <path
      fillRule="evenodd"
      clipRule="evenodd"
      d="M24.64 12.826c0 .86-1.044 1.286-1.646.671L10.676.907A15.974 15.974 0 0 1 16 0c3.183 0 6.148.93 8.64 2.531v10.295Zm4.48-5.986v5.986c0 4.875-5.919 7.289-9.328 3.804L6.545 3.091C2.576 6.003 0 10.701 0 16c0 3.407 1.065 6.565 2.88 9.16v-5.954c0-4.875 5.919-7.289 9.328-3.804l13.229 13.52C29.416 26.012 32 21.308 32 16c0-3.407-1.065-6.565-2.88-9.16ZM9.006 18.535 21.301 31.1C19.642 31.683 17.858 32 16 32c-3.182 0-6.148-.93-8.64-2.531V19.206c0-.86 1.045-1.286 1.646-.671Z"
      fill="currentColor"
    ></path>
    <path
      fillRule="evenodd"
      clipRule="evenodd"
      d="M24.64 12.826c0 .86-1.044 1.286-1.646.671L10.676.907A15.974 15.974 0 0 1 16 0c3.183 0 6.148.93 8.64 2.531v10.295Zm4.48-5.986v5.986c0 4.875-5.919 7.289-9.328 3.804L6.545 3.091C2.576 6.003 0 10.701 0 16c0 3.407 1.065 6.565 2.88 9.16v-5.954c0-4.875 5.919-7.289 9.328-3.804l13.229 13.52C29.416 26.012 32 21.308 32 16c0-3.407-1.065-6.565-2.88-9.16ZM9.006 18.535 21.301 31.1C19.642 31.683 17.858 32 16 32c-3.182 0-6.148-.93-8.64-2.531V19.206c0-.86 1.045-1.286 1.646-.671Z"
      fill="currentColor"
    ></path>
  </svg>
}
  >
    Send notifications using Novu
  </Card>

  <Card
    title="Knock"
    href="https://docs.knock.app/integrations/email/resend"
    icon={
  <svg
    className="h-6 w-6"
    width="14"
    height="20"
    viewBox="0 0 14 20"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Knock</title>
    <path
      d="M0 20V0.075058H4.19706V11.5013H4.31447L8.92243 5.90189H13.6184L8.51153 11.7003L14 20H9.33333L6.04612 14.5142L4.19706 16.5323V20H0Z"
      fill="currentColor"
    />
    <path
      d="M13.6748 2.45476C13.6748 3.81049 12.5399 4.90953 11.14 4.90953C9.74009 4.90953 8.60522 3.81049 8.60522 2.45476C8.60522 1.09904 9.74009 0 11.14 0C12.5399 0 13.6748 1.09904 13.6748 2.45476Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send notifications using Knock
  </Card>

  <Card
    title="Engagespot"
    href="https://docs.engagespot.co/docs/features/channels/email/resend/"
    icon={
  <svg className="h-6 w-6" fill="none" viewBox="0 0 38 35">
    <title>Engagespot</title>
    <g clipPath="url(#clip0_1_2)">
      <mask
        id="mask0_1_2"
        style={{ maskType: 'alpha' }}
        maskUnits="userSpaceOnUse"
        x="0"
        y="0"
        width="38"
        height="35"
      >
        <path d="M38 0H0V35H38V0Z" fill="currentColor" />
      </mask>
      <g mask="url(#mask0_1_2)">
        <mask
          id="mask1_1_2"
          style={{ maskType: 'alpha' }}
          maskUnits="userSpaceOnUse"
          x="0"
          y="0"
          width="39"
          height="35"
        >
          <path
            d="M36.9851 6.29843L28.4354 0.606125C27.3381 -0.131766 25.9208 -0.131766 24.8235 0.606125L19.2456 4.29559L19.1541 4.24287H19.1084L13.5762 0.553417C12.4789 -0.184472 11.0616 -0.184472 9.96426 0.553417L1.4145 6.24571C0.68297 6.72008 0.271484 7.61608 0.271484 8.56481V19.3696C0.271484 21.2144 1.14018 22.901 2.51179 23.797L19.1541 34.8127L35.8423 23.797C37.2137 22.901 38.0826 21.1616 38.0826 19.3169V8.56481C38.1283 7.61608 37.7168 6.77278 36.9851 6.29843Z"
            fill="currentColor"
          />
        </mask>
        <g mask="url(#mask1_1_2)">
          <path
            d="M12.7274 34.8008L-1.21742 26.2624L-1.62891 7.9206L11.8587 -1.88281L25.8035 6.65565L26.215 24.9975L12.7274 34.8008Z"
            fill="currentColor"
          />
          <path
            d="M27.5262 35.5996L13.6271 27.114L13.1699 8.77214L26.7033 -1.03125L40.6481 7.50719L41.0596 25.7963L27.5262 35.5996Z"
            fill="#B22977"
          />
          <path
            d="M19.9286 40.9787L6.02947 32.493L5.57228 14.151L19.1056 4.34766L29.5877 11.8891V31.0365L19.9286 40.9787Z"
            fill="currentColor"
          />
          <path
            opacity="0.36"
            d="M40.5925 21.2415L18.3265 37.2642L17.915 18.9751L41.0904 4.96094L40.5925 21.2415Z"
            fill="currentColor"
          />
          <path
            d="M-3.61505 22.8555L19.291 36.77L18.8795 18.4809L-4.07227 4.56641L-3.61505 22.8555Z"
            fill="currentColor"
          />
        </g>
        <mask
          id="mask2_1_2"
          style={{ maskType: 'alpha' }}
          maskUnits="userSpaceOnUse"
          x="0"
          y="0"
          width="39"
          height="35"
        >
          <path
            d="M36.9851 6.29843L28.4354 0.606125C27.3381 -0.131766 25.9208 -0.131766 24.8235 0.606125L19.2456 4.29559L19.1541 4.24287H19.1084L13.5762 0.553417C12.4789 -0.184472 11.0616 -0.184472 9.96426 0.553417L1.4145 6.24571C0.68297 6.72008 0.271484 7.61608 0.271484 8.56481V19.3696C0.271484 21.2144 1.14018 22.901 2.51179 23.797L19.1541 34.8127L35.8423 23.797C37.2137 22.901 38.0826 21.1616 38.0826 19.3169V8.56481C38.1283 7.61608 37.7168 6.77278 36.9851 6.29843Z"
            fill="currentColor"
          />
        </mask>
        <g mask="url(#mask2_1_2)">
          <path
            d="M12.7274 34.8008L-1.21742 26.2624L-1.62891 7.9206L11.8587 -1.88281L25.8035 6.65565L26.215 24.9975L12.7274 34.8008Z"
            fill="currentColor"
          />
          <path
            d="M27.5262 35.5996L13.6271 27.114L13.1699 8.77214L26.7033 -1.03125L40.6481 7.50719L41.0596 25.7963L27.5262 35.5996Z"
            fill="currentColor"
          />
          <path
            d="M19.9286 40.9787L6.02947 32.493L5.57228 14.151L19.1056 4.34766L29.5877 11.8891V31.0365L19.9286 40.9787Z"
            fill="currentColor"
          />
          <path
            d="M40.5925 21.2415L18.3265 37.2642L17.915 18.9751L41.0904 4.96094L40.5925 21.2415Z"
            fill="currentColor"
          />
          <path
            d="M-3.61505 22.8555L19.291 36.77L18.8795 18.4809L-4.07227 4.56641L-3.61505 22.8555Z"
            fill="currentColor"
          />
        </g>
      </g>
    </g>
    <defs>
      <clipPath id="clip0_1_2">
        <rect width="38" height="35" fill="currentColor" />
      </clipPath>
    </defs>
  </svg>
}
  >
    Send notifications using Engagespot
  </Card>

  <Card
    title="Dittofeed"
    href="https://docs.dittofeed.com/integrations/channels/resend"
    icon={
  <svg className="h-6 w-6" viewBox="0 0 40 38" fill="none">
    <title>Dittofeed</title>
    <path
      fillRule="evenodd"
      clipRule="evenodd"
      d="M25.5907 33.1617C27.229 27.0472 24.4917 21.0012 19.4767 19.6575C14.4617 18.3138 9.06812 22.1811 7.42981 28.2953C5.93843 33.8613 9.318 34.724 13.7192 35.8477C14.1529 35.9585 14.5965 36.0716 15.0463 36.1922C15.4961 36.3127 15.9369 36.4365 16.3678 36.5574C20.7411 37.785 24.0994 38.7274 25.5907 33.1617ZM21.5024 30.5195C22.3244 27.4521 20.9385 24.4156 18.4071 23.7373C15.8756 23.059 13.1571 24.9957 12.3352 28.0633C11.5627 30.946 13.3777 31.4228 15.7003 32.0329C15.8491 32.0718 15.9999 32.1114 16.1522 32.1522C16.3046 32.1931 16.455 32.2342 16.6034 32.2748C18.9198 32.9078 20.73 33.4025 21.5024 30.5195ZM13.8755 4.33377C12.2371 10.4481 14.9745 16.494 19.9895 17.8378C25.0046 19.1816 30.3982 15.3143 32.0365 9.19999C33.5278 3.63409 30.1482 2.77127 25.7471 1.64761C25.3133 1.53691 24.8699 1.42365 24.42 1.30314C23.9702 1.1826 23.5293 1.05888 23.0985 0.937938C18.7251 -0.289572 15.3669 -1.23214 13.8755 4.33377ZM17.9636 6.97574C17.1416 10.0433 18.5275 13.0798 21.059 13.7582C23.5905 14.4365 26.309 12.4996 27.1308 9.4321C27.9032 6.54919 26.0883 6.07253 23.7657 5.46254C23.617 5.42348 23.4662 5.38387 23.3137 5.34303C23.1614 5.30222 23.011 5.26111 22.8626 5.22057C20.5462 4.58752 18.7361 4.09283 17.9636 6.97574ZM2.51398 23.1191C6.37268 24.1531 10.5065 21.2378 11.7471 16.6078C12.9878 11.9777 10.8654 7.38613 7.00667 6.35219C3.49407 5.41099 2.68583 8.52804 1.63326 12.5874C1.52956 12.9874 1.42348 13.3965 1.31219 13.8118C1.20091 14.227 1.08823 14.6344 0.97806 15.0326C-0.140057 19.0744 -0.998623 22.1779 2.51398 23.1191ZM4.85546 18.5831C6.47756 19.0177 8.22079 17.7718 8.74908 15.8001C9.27738 13.8285 8.39069 11.8778 6.76859 11.4432C5.24412 11.0347 4.87063 12.4477 4.39264 14.2559C4.36203 14.3717 4.33099 14.4891 4.2992 14.6078C4.26742 14.7265 4.23559 14.8437 4.20419 14.9592C3.71403 16.7642 3.33099 18.1746 4.85546 18.5831ZM36.9296 14.3759C33.0707 13.3419 28.937 16.2572 27.6964 20.8872C26.4558 25.5174 28.5781 30.1088 32.4367 31.1428C35.9494 32.084 36.7576 28.967 37.8102 24.9078C37.9139 24.5078 38.02 24.0986 38.1313 23.6834C38.2425 23.268 38.3552 22.8607 38.4654 22.4624C39.5835 18.4206 40.4421 15.3171 36.9296 14.3759ZM34.5879 18.912C32.9659 18.4773 31.2226 19.7233 30.6945 21.6949C30.1661 23.6665 31.0528 25.6173 32.6748 26.0519C34.1993 26.4603 34.5728 25.0474 35.0508 23.2391C35.0814 23.1234 35.1124 23.0059 35.1443 22.8872C35.176 22.7685 35.2078 22.6515 35.2393 22.5358C35.7293 20.7309 36.1124 19.3204 34.5879 18.912Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send automated emails using Dittofeed
  </Card>

  <Card
    title="Suprsend"
    href="https://docs.suprsend.com/docs/resend"
    icon={
  <svg className="h-6 w-6"  width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
    <title>Suprsend</title>
    <path d="M26.5777 4.65928L19.5223 8.79046L19.5364 0.585938L26.5777 4.65928Z" fill="currentColor"/>
    <path d="M19.5222 8.79164L12.2794 12.6862L12.478 4.58008L19.5222 8.79164Z" fill="currentColor"/>
    <path d="M12.3217 12.6661L5.19641 16.614L5.39497 8.50781L12.3217 12.6661Z" fill="currentColor"/>
    <path d="M5.19037 16.6146L12.3024 20.8912L12.3149 12.6621L5.19037 16.6146Z" fill="currentColor"/>
    <path d="M19.5233 8.79147L12.48 4.5799L19.538 0.587891L19.5233 8.79147Z" fill="currentColor"/>
    <path d="M12.3187 12.668L5.39081 8.51372L12.4814 4.58008L12.3187 12.668Z" fill="currentColor"/>
    <path d="M5.31079 27.7316L12.3206 23.5234L12.3962 31.7277L5.31079 27.7316Z" fill="currentColor"/>
    <path d="M12.3195 23.5263L19.5191 19.5527L19.4092 27.6606L12.3195 23.5263Z" fill="currentColor"/>
    <path d="M19.4817 19.5724L26.5634 15.5469L26.4535 23.6546L19.4817 19.5724Z" fill="currentColor"/>
    <path d="M26.5614 15.5442L19.4031 11.3457L19.4805 19.5745L26.5614 15.5442Z" fill="currentColor"/>
    <path d="M12.3188 23.5254L19.4077 27.6596L12.3939 31.7286L12.3188 23.5254Z" fill="currentColor"/>
    <path d="M19.4808 19.5703L26.4537 23.6486L19.4067 27.6596L19.4808 19.5703Z" fill="currentColor"/>
  </svg>
}
  >
    Send notifications using Suprsend
  </Card>
</CardGroup>

## Content Management Systems

<CardGroup>
  <Card
    title="Payload CMS"
    href="https://payloadcms.com/docs/email/overview#resend-configuration"
    icon={
  <svg className="h-6 w-6" viewBox="0 0 40 40" fill="none">
    <title>Payload CMS</title>
    <path
      d="M18.4469 0L36.8 11.0415V31.9965L22.9773 40V19.0451L4.61523 8.01243L18.4469 0Z"
      fill="currentColor"
    />
    <path
      d="M17.0495 38.8363V22.4829L3.20001 30.5042L17.0495 38.8363Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send emails using Payload CMS
  </Card>

  <Card
    title="Strapi CMS"
    href="https://strapi.io/integrations/resend"
    icon={
  <svg className="h-6 w-6" viewBox="0 0 244 244" fill="none" xmlns="http://www.w3.org/2000/svg">
    <title>Strapi CMS</title>
    <g clip-path="url(#clip0_1151_17)">
      <path d="M159.413 0C199.288 0 219.225 0.000262921 231.612 12.3877C244 24.7751 244 44.7125 244 84.5869V159.413C244 199.288 244 219.225 231.612 231.612C219.225 244 199.288 244 159.413 244H84.5869C44.7125 244 24.7751 244 12.3877 231.612C0.000262921 219.225 0 199.288 0 159.413V84.5869C0 44.7124 0.000262921 24.7751 12.3877 12.3877C24.7751 0.000262921 44.7124 0 84.5869 0H159.413ZM86.2129 74.0137L45.7148 114.512C45.2024 115.024 45.5654 115.9 46.29 115.9H86.2129V156.16C86.2129 157.058 86.9416 157.787 87.8398 157.787H128.1V197.71C128.1 198.434 128.976 198.798 129.488 198.285L169.986 157.787V75.6406C169.986 74.7424 169.259 74.0139 168.36 74.0137H86.2129ZM128.1 117.527C128.1 116.629 127.372 115.901 126.474 115.9H128.1V117.527Z" fill="currentColor"/>
      <path d="M128.1 115.9H126.473V117.527H128.1V115.9Z" fill="currentColor"/>
    </g>
    <defs>
      <clipPath id="clip0_1151_17">
        <rect width="244" height="244" fill="currentColor"/>
      </clipPath>
    </defs>
  </svg>
}
  >
    Send emails using Strapi CMS
  </Card>
</CardGroup>

## Developer tools

<CardGroup>
  <Card
    title="Convex"
    href="https://www.convex.dev/components/resend"
    icon={
  <svg
    className="h-6 w-6"
    width="122"
    height="125"
    viewBox="0 0 122 125"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <path
      d="M75.9376 96.0309C92.8004 94.1524 108.699 85.1418 117.452 70.103C113.307 107.301 72.7453 130.811 39.6369 116.377C36.586 115.05 33.96 112.843 32.1579 110.006C24.7175 98.2901 22.2717 83.3825 25.7859 69.8535C35.8265 87.2306 56.2425 97.8824 75.9376 96.0309Z"
      fill="currentColor"
    />
    <path
      d="M25.1702 58.9393C18.3348 74.7791 18.0388 93.3254 26.4188 108.588C-3.0724 86.3385 -2.75057 38.7252 26.0584 16.6986C28.723 14.6627 31.8897 13.4543 35.2108 13.2705C48.8687 12.548 62.7455 17.8413 72.477 27.7054C52.7048 27.9023 33.4473 40.6035 25.1702 58.9393Z"
      fill="currentColor"
    />
    <path
      d="M82.013 32.5765C72.037 18.6276 56.4223 9.13129 39.3146 8.84235C72.3841 -6.20988 113.061 18.1941 117.49 54.2748C117.902 57.6241 117.361 61.0391 115.881 64.06C109.702 76.6428 98.2455 86.4018 84.8581 90.0135C94.6671 71.7697 93.4566 49.4806 82.013 32.5765Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send emails with Convex's Resend Component
  </Card>

  <Card
    title="Inngest"
    href="https://www.inngest.com/docs/guides/resend-webhook-events"
    icon={
  <svg className="h-6 w-6" fill="none" viewBox="0 0 270 270">
    <title>Inngest</title>
    <mask
      id="mask0_680_113"
      style={{ maskType: 'alpha' }}
      maskUnits="userSpaceOnUse"
      x="21"
      y="2"
      width="228"
      height="265"
    >
      <path
        fillRule="evenodd"
        clipRule="evenodd"
        d="M145.841 5.0459L238.431 60.6531C244.777 64.506 248.73 71.3788 248.626 78.8764V189.987C248.626 197.484 244.777 204.357 238.327 208.21L145.737 263.817C141.783 266.421 133.669 269.44 123.89 263.817L31.2994 208.21C24.9533 204.357 21 197.484 21 189.987V78.8764C21 71.3788 24.8492 64.506 31.2994 60.6531L123.994 5.0459C130.756 0.9847 139.078 0.9847 145.841 5.0459ZM77.9258 134.5C67.446 134.5 58.9504 142.996 58.9504 153.475C58.9504 163.955 67.446 172.451 77.9258 172.451C82.9583 172.451 87.7848 170.452 91.3433 166.893C94.9019 163.334 96.9011 158.508 96.9011 153.475C96.9011 142.996 88.4055 134.5 77.9258 134.5ZM134.852 115.525C124.372 115.525 115.876 124.02 115.876 134.5C115.876 144.98 124.372 153.475 134.852 153.475C139.884 153.475 144.711 151.476 148.269 147.918C151.828 144.359 153.827 139.533 153.827 134.5C153.827 124.02 145.331 115.525 134.852 115.525ZM191.778 96.5494C181.298 96.5494 172.802 105.045 172.802 115.525C172.802 126.005 181.298 134.5 191.778 134.5C196.81 134.5 201.637 132.501 205.195 128.942C208.754 125.384 210.753 120.557 210.753 115.525C210.753 105.045 202.257 96.5494 191.778 96.5494Z"
        fill="currentColor"
      />
    </mask>
    <g mask="url(#mask0_680_113)">
      <rect x="21" y="2" width="227.704" height="265" fill="currentColor" />
    </g>
  </svg>
}
  >
    Send drip campaigns using Inngest
  </Card>

  <Card
    title="Upstash"
    href="https://upstash.com/docs/qstash/integrations/resend"
    icon={
  <svg
    className="h-6 w-6"
    width="354"
    height="472"
    viewBox="0 0 354 472"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Upstash</title>
    <path
      d="M0.421875 412.975C78.5269 491.079 205.16 491.079 283.265 412.975C361.369 334.87 361.369 208.237 283.265 130.132L247.909 165.487C306.488 224.066 306.488 319.041 247.909 377.619C189.331 436.198 94.3559 436.198 35.7769 377.619L0.421875 412.975Z"
      fill="currentColor"
    />
    <path
      d="M71.1328 342.264C110.185 381.316 173.501 381.316 212.554 342.264C251.606 303.212 251.606 239.895 212.554 200.843L177.199 236.198C196.725 255.724 196.725 287.382 177.199 306.909C157.672 326.435 126.014 326.435 106.488 306.909L71.1328 342.264Z"
      fill="currentColor"
    />
    <path
      d="M353.974 59.4209C275.869 -18.6836 149.236 -18.6836 71.1315 59.4209C-6.97352 137.526 -6.97352 264.159 71.1315 342.264L106.486 306.909C47.9085 248.33 47.9085 153.355 106.486 94.7769C165.065 36.1979 260.04 36.1979 318.618 94.7769L353.974 59.4209Z"
      fill="currentColor"
    />
    <path
      d="M283.264 130.132C244.212 91.08 180.894 91.08 141.842 130.132C102.789 169.185 102.789 232.501 141.842 271.553L177.197 236.198C157.671 216.672 157.671 185.014 177.197 165.487C196.723 145.961 228.381 145.961 247.908 165.487L283.264 130.132Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send emails using Upstash
  </Card>

  <Card
    title="Trigger.dev"
    href="https://trigger.dev/docs/guides/examples/resend-email-sequence"
    icon={
  <svg
    className="h-6 w-6"
    width="199"
    height="174"
    viewBox="0 0 199 174"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Trigger.dev</title>
    <path
      fillRule="evenodd"
      clipRule="evenodd"
      d="M59.3512 70.3883L99.5 0.849602L199 173.191H0L40.1488 103.65L68.5493 120.048L56.8032 140.394H142.197L99.5 66.4424L87.7539 86.7881L59.3512 70.3883Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send drip campaigns using Trigger.dev
  </Card>

  <Card
    title="Infisical"
    href="https://infisical.com/docs/self-hosting/configuration/envars#resend"
    icon={
  <svg
    className="h-6 w-6"
    width="91"
    height="43"
    viewBox="0 0 91 43"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Infisical</title>
    <path
      d="M21.9734 0C24.8526 0 27.4793 0.412021 29.8535 1.23606C32.2528 2.06011 34.4123 3.13386 36.3318 4.45732C38.2766 5.75581 39.9814 7.10424 41.4463 8.50261C42.2545 9.25174 42.987 9.98839 43.6436 10.7125C44.3003 11.4367 44.9317 12.1609 45.5379 12.885C46.0935 12.1609 46.6618 11.4617 47.2427 10.7875C47.8489 10.0883 48.6066 9.32665 49.5158 8.50261C51.7132 6.38008 54.4409 4.43235 57.699 2.65941C60.9824 0.886471 64.7835 0 69.1024 0C73.1435 0 76.8183 0.97387 80.127 2.92161C83.4609 4.84437 86.1002 7.42886 88.045 10.6751C90.015 13.9213 91 17.5171 91 21.4625C91 24.4591 90.4317 27.2683 89.2952 29.8902C88.1586 32.4872 86.5927 34.7721 84.5974 36.7448C82.6021 38.6925 80.2785 40.2282 77.6266 41.3519C74.9746 42.4506 72.1332 43 69.1024 43C66.2231 43 63.5712 42.6005 61.1465 41.8014C58.7472 40.9774 56.5751 39.9286 54.6303 38.6551C52.7108 37.3815 51.0186 36.0706 49.5537 34.7221C48.7202 33.8981 47.9752 33.124 47.3185 32.3998C46.6871 31.6507 46.0935 30.9141 45.5379 30.1899C44.9065 30.9141 44.2624 31.6507 43.6057 32.3998C42.9491 33.149 42.2166 33.9231 41.4084 34.7221C39.9688 36.0706 38.2766 37.3815 36.3318 38.6551C34.4123 39.9036 32.2528 40.9399 29.8535 41.7639C27.4793 42.588 24.8526 43 21.9734 43C17.8818 43 14.1817 42.0386 10.873 40.1159C7.56439 38.1931 4.92506 35.6086 2.95504 32.3624C0.985013 29.0912 0 25.4579 0 21.4625C0 18.491 0.555648 15.7192 1.66694 13.1472C2.8035 10.5502 4.36941 8.26539 6.3647 6.29269C8.38523 4.31998 10.7215 2.78427 13.3734 1.68554C16.0507 0.561848 18.9173 0 21.9734 0ZM10.4563 21.4625C10.4563 23.5351 10.974 25.4204 12.0096 27.1185C13.0451 28.8165 14.4342 30.1649 16.1769 31.1638C17.9197 32.1626 19.8518 32.662 21.9734 32.662C24.3475 32.662 26.5322 32.1376 28.5275 31.0889C30.5228 30.0401 32.3791 28.7166 34.0966 27.1185C35.1826 26.0947 36.1171 25.1083 36.9001 24.1594C37.683 23.2105 38.365 22.3116 38.9459 21.4625C38.3397 20.6635 37.6199 19.777 36.7864 18.8031C35.9782 17.8043 35.0816 16.8554 34.0966 15.9564C32.4802 14.3833 30.649 13.0598 28.6032 11.9861C26.5575 10.8873 24.3475 10.338 21.9734 10.338C19.8518 10.338 17.9197 10.8499 16.1769 11.8737C14.4342 12.8725 13.0451 14.221 12.0096 15.919C10.974 17.592 10.4563 19.4399 10.4563 21.4625ZM80.4679 21.4625C80.4679 19.4399 79.9502 17.592 78.9146 15.919C77.9044 14.221 76.5405 12.8725 74.8231 11.8737C73.1056 10.8499 71.1987 10.338 69.1024 10.338C67.486 10.338 65.9453 10.5877 64.4804 11.0871C63.0155 11.5865 61.639 12.2607 60.351 13.1098C59.0881 13.9588 57.9263 14.9077 56.8655 15.9564C55.729 17.0052 54.7313 18.079 53.8726 19.1777C53.0139 20.2515 52.3951 21.0131 52.0162 21.4625C52.6477 22.3365 53.3549 23.248 54.1378 24.1969C54.9208 25.1208 55.83 26.0947 56.8655 27.1185C58.5577 28.7166 60.4015 30.0401 62.3968 31.0889C64.4173 32.1376 66.6525 32.662 69.1024 32.662C71.1987 32.662 73.1056 32.1626 74.8231 31.1638C76.5405 30.1649 77.9044 28.8165 78.9146 27.1185C79.9502 25.4204 80.4679 23.5351 80.4679 21.4625Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send email when self-hosting Infisical
  </Card>

  <Card
    title="Fastgen"
    href="https://docs.fastgen.com/actions/integrations/resend"
    icon={
  <svg
    className="h-6 w-6"
    width="341"
    height="639"
    viewBox="0 0 341 639"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Fastgen</title>
    <path
      d="M124.055 281.936C85.4199 323.452 41.1491 402.46 167.61 525.124C169.054 525.852 169.226 525.647 167.799 522.085C162.896 509.841 148.76 473.417 147.658 441.383C146.236 400.028 165.156 370.923 174.248 360.761C198.862 333.247 276.425 258.605 309.11 226.217C341.795 193.829 342.822 131.017 339.915 95.628C337.589 67.3167 334.499 72.6184 331.23 75.8291C286.8 120.721 167.035 239.46 124.055 281.936Z"
      fill="currentColor"
    />
    <path
      d="M191.752 543.303C190.004 541.192 166.79 490.436 166.415 451.524C165.007 427.954 168.397 412.593 170.652 401.957C171.473 400.141 172.512 399.788 173.489 400.748C198.436 425.247 260.074 494.383 264.655 499.052C270.399 504.904 276.598 517.658 276.598 517.658C286.61 536.3 298.531 570.561 295.876 608.76C293.891 637.323 292.119 639.736 289.687 638.817C288.292 638.29 272.502 622.982 258.003 608.925C247.209 598.461 237.131 588.69 234.238 586.226C227.46 580.451 208.67 562.084 194.368 546.421C193.493 545.462 193.501 545.413 191.752 543.303Z"
      fill="currentColor"
    />
    <path
      d="M40.6974 208.722C2.06224 250.238 -43.3264 322.115 83.1343 444.78C84.5784 445.508 84.7501 445.302 83.3235 441.74C78.4202 429.497 65.4019 400.203 64.3002 368.169C62.8779 326.814 81.7983 297.709 90.8898 287.547C115.504 260.033 193.067 185.392 225.752 153.003C258.437 120.615 259.464 57.8032 256.557 22.4142C254.232 -5.89712 251.142 -0.59542 247.872 2.61528C203.442 47.507 83.6775 166.246 40.6974 208.722Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Build workflows using Fastgen
  </Card>

  <Card
    title="Medusa"
    href="https://docs.medusajs.com/resources/integrations/guides/resend"
    icon={
  <svg
    className="h-6 w-6"
    width="488"
    height="488"
    viewBox="0 0 488 488"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Medusa</title>
    <path
      d="M394.468 97.5239L296.258 41.013C264.125 22.4774 224.751 22.4774 192.618 41.013L93.9554 97.5239C62.2748 116.06 42.3613 150.418 42.3613 187.037V300.511C42.3613 337.582 62.2748 371.489 93.9554 390.024L192.165 446.987C224.298 465.523 263.673 465.523 295.806 446.987L394.015 390.024C426.149 371.489 445.61 337.582 445.61 300.511V187.037C446.515 150.418 426.601 116.06 394.468 97.5239ZM244.212 344.816C188.544 344.816 143.287 299.607 143.287 244C143.287 188.393 188.544 143.185 244.212 143.185C299.879 143.185 345.589 188.393 345.589 244C345.589 299.607 300.332 344.816 244.212 344.816Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send e-commerce emails using Medusa
  </Card>

  <Card
    title="OpenMeter"
    href="https://openmeter.io/docs/reporting/email"
    icon={
  <svg className="h-6 w-6" fill="none" viewBox="0 0 24 24">
    <title>OpenMeter</title>
    <path
      d="M10.238 8.44 7.28 6.519l-4.909 9.565.06.04h3.863l3.944-7.684ZM15.786 8.44 12.83 6.519l-4.91 9.565.061.04h3.863l3.943-7.684ZM21.335 8.44l-2.957-1.921-4.91 9.565.06.04h3.864l3.943-7.684Z"
      fill="currentColor"
      clipRule="evenodd"
    />
  </svg>
}
  >
    Send usage emails using OpenMeter
  </Card>

  <Card
    title="Invopop"
    href="https://docs.invopop.com/guides/features/email"
    icon={
  <svg className="h-6 w-6" fill="none" viewBox="0 0 40 41">
    <title>Invopop</title>
    <path
      d="M38.7166 38.5342L37.8332 37.7778H10.2562C10.0628 37.7782 9.87562 37.7081 9.72878 37.5802L2.17692 31.1328H1.82092C1.65297 31.1324 1.48897 31.1845 1.35122 31.2821C1.21347 31.3797 1.10866 31.518 1.05103 31.6782C0.993406 31.8384 0.985766 32.0127 1.02915 32.1775C1.07253 32.3422 1.16484 32.4895 1.29351 32.5991L9.72878 39.8231C9.87668 39.9487 10.0634 40.0175 10.2562 40.0172H38.1859C38.3582 40.0228 38.5277 39.9731 38.6703 39.875C38.813 39.777 38.9216 39.6355 38.9804 39.4711C39.0393 39.3067 39.0454 39.1275 38.998 38.9592C38.9507 38.7911 38.8522 38.6422 38.7166 38.5342Z"
      fill="currentColor"
    />
    <path
      d="M38.7166 34.0882L37.8332 33.3316H10.2562C10.0628 33.3321 9.87562 33.2619 9.72878 33.1341L2.17692 26.6699H1.82092C1.65297 26.6696 1.48897 26.7216 1.35122 26.8192C1.21347 26.9168 1.10866 27.0551 1.05103 27.2154C0.993406 27.3755 0.985766 27.5499 1.02915 27.7146C1.07253 27.8794 1.16484 28.0266 1.29351 28.1362L9.72878 35.3569C9.87562 35.4848 10.0628 35.5549 10.2562 35.5545H38.1859C38.3542 35.5555 38.5186 35.5039 38.6569 35.4066C38.7952 35.3094 38.9004 35.1711 38.9586 35.0106C39.0166 34.8504 39.0244 34.6756 38.9812 34.5106C38.9379 34.3455 38.8454 34.1979 38.7166 34.0882Z"
      fill="currentColor"
    />
    <path
      d="M38.7164 16.3087L37.833 15.5522H10.256C10.0629 15.5538 9.8757 15.4849 9.72854 15.3581L2.17668 8.89387H1.82068C1.64876 8.88903 1.47971 8.93936 1.33758 9.03772C1.19546 9.13609 1.0875 9.27746 1.02908 9.44175C0.970657 9.60602 0.96474 9.78482 1.01217 9.95272C1.0596 10.1206 1.15797 10.269 1.29327 10.3768L9.95598 17.7749L20.1087 26.4787C20.2574 26.6049 20.4454 26.6738 20.6394 26.6728H27.4529L28.3363 27.4294C28.4643 27.5395 28.5561 27.6869 28.5991 27.8517C28.6421 28.0164 28.6344 28.1907 28.5769 28.3508C28.5194 28.5109 28.415 28.6494 28.2777 28.7474C28.1403 28.8454 27.9767 28.8982 27.8089 28.8989H20.6394C20.4477 28.8945 20.2634 28.8222 20.1186 28.6947L12.537 22.2238H1.82068C1.65273 22.2234 1.48873 22.2755 1.35098 22.3731C1.21323 22.4707 1.10842 22.6089 1.05079 22.7692C0.993168 22.9294 0.985528 23.1038 1.02891 23.2685C1.0723 23.4332 1.1646 23.5805 1.29327 23.6901L9.72854 30.9108C9.87539 31.0387 10.0625 31.1087 10.256 31.1082H38.1857C38.3539 31.1084 38.5179 31.0559 38.6557 30.9582C38.7936 30.8604 38.8986 30.7221 38.9564 30.5618C39.0143 30.4015 39.0224 30.2269 38.9794 30.0618C38.9364 29.8968 38.8447 29.7491 38.7164 29.6387L27.4529 19.9978H20.6394C20.449 19.9949 20.2654 19.9265 20.1186 19.8035L17.7451 17.7749H38.1824C38.3509 17.7768 38.5159 17.7257 38.6546 17.6287C38.7934 17.5315 38.8993 17.3934 38.9577 17.2328C39.0163 17.0722 39.0244 16.8974 38.9811 16.7319C38.938 16.5665 38.8454 16.4187 38.7164 16.3087ZM20.1186 22.0264C20.2673 22.1527 20.4553 22.2215 20.6493 22.2205H27.4561L28.3363 22.9737C28.4637 23.0837 28.5549 23.2307 28.5974 23.3948C28.64 23.5589 28.6321 23.7324 28.5746 23.8918C28.5171 24.0512 28.4129 24.1889 28.276 24.2864C28.139 24.3838 27.976 24.4362 27.8089 24.4367H20.6394C20.4496 24.4371 20.2656 24.3709 20.1186 24.2491L12.537 17.7749H15.1345L20.1186 22.0264Z"
      fill="currentColor"
    />
    <path
      d="M38.7165 11.8635L37.8331 11.107H10.2561C10.0633 11.1072 9.87657 11.0384 9.72869 10.9128L2.17681 4.44531H1.82081C1.65296 4.44594 1.48934 4.49884 1.352 4.59684C1.21466 4.69484 1.11021 4.83326 1.05273 4.99341C0.995257 5.15357 0.987512 5.32777 1.03054 5.49254C1.07358 5.65731 1.16532 5.80471 1.2934 5.91488L9.72869 13.1356C9.87585 13.2625 10.063 13.3314 10.2561 13.3297H38.1858C38.354 13.3308 38.5185 13.2792 38.6568 13.1819C38.7951 13.0846 38.9004 12.9463 38.9584 12.786C39.0165 12.6256 39.0244 12.451 38.9811 12.2859C38.9378 12.1208 38.8454 11.9733 38.7165 11.8635Z"
      fill="currentColor"
    />
    <path
      d="M1.29387 1.46623L9.72916 8.70366C9.87704 8.82927 10.0638 8.89801 10.2566 8.89781H38.1863C38.3545 8.89893 38.519 8.84731 38.6573 8.75C38.7955 8.65269 38.9009 8.51443 38.9589 8.35407C39.0169 8.19371 39.0249 8.01907 38.9816 7.85399C38.9383 7.68889 38.8459 7.54139 38.717 7.43159L30.2817 0.194161C30.1332 0.069775 29.9469 0.00120419 29.7543 2.55058e-06H1.82128C1.65334 -0.000420119 1.48934 0.0516987 1.35159 0.149271C1.21384 0.246844 1.10902 0.385136 1.0514 0.545339C0.993773 0.705541 0.986132 0.879881 1.02952 1.04465C1.0729 1.20942 1.1652 1.35662 1.29387 1.46623Z"
      fill="currentColor"
    />
    <path
      d="M38.7166 38.5342L37.8332 37.7778H10.2562C10.0628 37.7782 9.87562 37.7081 9.72878 37.5802L2.17692 31.1328H1.82092C1.65297 31.1324 1.48897 31.1845 1.35122 31.2821C1.21347 31.3797 1.10866 31.518 1.05103 31.6782C0.993406 31.8384 0.985766 32.0127 1.02915 32.1775C1.07253 32.3422 1.16484 32.4895 1.29351 32.5991L9.72878 39.8231C9.87668 39.9487 10.0634 40.0175 10.2562 40.0172H38.1859C38.3582 40.0228 38.5277 39.9731 38.6703 39.875C38.813 39.777 38.9216 39.6355 38.9804 39.4711C39.0393 39.3067 39.0454 39.1275 38.998 38.9592C38.9507 38.7911 38.8522 38.6422 38.7166 38.5342Z"
      fill="currentColor"
    />
    <path
      d="M38.7166 34.0882L37.8332 33.3316H10.2562C10.0628 33.3321 9.87562 33.2619 9.72878 33.1341L2.17692 26.6699H1.82092C1.65297 26.6696 1.48897 26.7216 1.35122 26.8192C1.21347 26.9168 1.10866 27.0551 1.05103 27.2154C0.993406 27.3755 0.985766 27.5499 1.02915 27.7146C1.07253 27.8794 1.16484 28.0266 1.29351 28.1362L9.72878 35.3569C9.87562 35.4848 10.0628 35.5549 10.2562 35.5545H38.1859C38.3542 35.5555 38.5186 35.5039 38.6569 35.4066C38.7952 35.3094 38.9004 35.1711 38.9586 35.0106C39.0166 34.8504 39.0244 34.6756 38.9812 34.5106C38.9379 34.3455 38.8454 34.1979 38.7166 34.0882Z"
      fill="currentColor"
    />
    <path
      d="M38.7164 16.3087L37.833 15.5522H10.256C10.0629 15.5538 9.8757 15.4849 9.72854 15.3581L2.17668 8.89387H1.82068C1.64876 8.88903 1.47971 8.93936 1.33758 9.03772C1.19546 9.13609 1.0875 9.27746 1.02908 9.44175C0.970657 9.60602 0.96474 9.78482 1.01217 9.95272C1.0596 10.1206 1.15797 10.269 1.29327 10.3768L9.95598 17.7749L20.1087 26.4787C20.2574 26.6049 20.4454 26.6738 20.6394 26.6728H27.4529L28.3363 27.4294C28.4643 27.5395 28.5561 27.6869 28.5991 27.8517C28.6421 28.0164 28.6344 28.1907 28.5769 28.3508C28.5194 28.5109 28.415 28.6494 28.2777 28.7474C28.1403 28.8454 27.9767 28.8982 27.8089 28.8989H20.6394C20.4477 28.8945 20.2634 28.8222 20.1186 28.6947L12.537 22.2238H1.82068C1.65273 22.2234 1.48873 22.2755 1.35098 22.3731C1.21323 22.4707 1.10842 22.6089 1.05079 22.7692C0.993168 22.9294 0.985528 23.1038 1.02891 23.2685C1.0723 23.4332 1.1646 23.5805 1.29327 23.6901L9.72854 30.9108C9.87539 31.0387 10.0625 31.1087 10.256 31.1082H38.1857C38.3539 31.1084 38.5179 31.0559 38.6557 30.9582C38.7936 30.8604 38.8986 30.7221 38.9564 30.5618C39.0143 30.4015 39.0224 30.2269 38.9794 30.0618C38.9364 29.8968 38.8447 29.7491 38.7164 29.6387L27.4529 19.9978H20.6394C20.449 19.9949 20.2654 19.9265 20.1186 19.8035L17.7451 17.7749H38.1824C38.3509 17.7768 38.5159 17.7257 38.6546 17.6287C38.7934 17.5315 38.8993 17.3934 38.9577 17.2328C39.0163 17.0722 39.0244 16.8974 38.9811 16.7319C38.938 16.5665 38.8454 16.4187 38.7164 16.3087ZM20.1186 22.0264C20.2673 22.1527 20.4553 22.2215 20.6493 22.2205H27.4561L28.3363 22.9737C28.4637 23.0837 28.5549 23.2307 28.5974 23.3948C28.64 23.5589 28.6321 23.7324 28.5746 23.8918C28.5171 24.0512 28.4129 24.1889 28.276 24.2864C28.139 24.3838 27.976 24.4362 27.8089 24.4367H20.6394C20.4496 24.4371 20.2656 24.3709 20.1186 24.2491L12.537 17.7749H15.1345L20.1186 22.0264Z"
      fill="currentColor"
    />
    <path
      d="M38.7165 11.8635L37.8331 11.107H10.2561C10.0633 11.1072 9.87657 11.0384 9.72869 10.9128L2.17681 4.44531H1.82081C1.65296 4.44594 1.48934 4.49884 1.352 4.59684C1.21466 4.69484 1.11021 4.83326 1.05273 4.99341C0.995257 5.15357 0.987512 5.32777 1.03054 5.49254C1.07358 5.65731 1.16532 5.80471 1.2934 5.91488L9.72869 13.1356C9.87585 13.2625 10.063 13.3314 10.2561 13.3297H38.1858C38.354 13.3308 38.5185 13.2792 38.6568 13.1819C38.7951 13.0846 38.9004 12.9463 38.9584 12.786C39.0165 12.6256 39.0244 12.451 38.9811 12.2859C38.9378 12.1208 38.8454 11.9733 38.7165 11.8635Z"
      fill="currentColor"
    />
    <path
      d="M1.29387 1.46623L9.72916 8.70366C9.87704 8.82927 10.0638 8.89801 10.2566 8.89781H38.1863C38.3545 8.89893 38.519 8.84731 38.6573 8.75C38.7955 8.65269 38.9009 8.51443 38.9589 8.35407C39.0169 8.19371 39.0249 8.01907 38.9816 7.85399C38.9383 7.68889 38.8459 7.54139 38.717 7.43159L30.2817 0.194161C30.1332 0.069775 29.9469 0.00120419 29.7543 2.55058e-06H1.82128C1.65334 -0.000420119 1.48934 0.0516987 1.35159 0.149271C1.21384 0.246844 1.10902 0.385136 1.0514 0.545339C0.993773 0.705541 0.986132 0.879881 1.02952 1.04465C1.0729 1.20942 1.1652 1.35662 1.29387 1.46623Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send invoice emails using Invopop
  </Card>

  <Card
    title="Tinybird"
    href="https://www.tinybird.co/docs/get-data-in/guides/ingest-from-resend"
    icon={
  <svg className="h-6 w-6" fill="none" viewBox="0 0 24 24">
    <path
      d="M9.971 18.125 0 14.556l13.967-4.88L16.507 4 24 6.055l-4.407 1.669-2.735 12.754.097.039L5.946 28l4.025-9.875Z"
      fill="currentColor"
      transform="translate(0 -4)"
    />
  </svg>
}
  >
    Analyze your email data in real time
  </Card>

  <Card
    title="Coolify"
    href="https://coolify.io/docs/knowledge-base/notifications#resend-configuration"
    icon={
  <svg
    className="h-6 w-6"
    width="66"
    height="66"
    viewBox="0 0 66 66"
    fill="none"
    xmlns="http://www.w3.org/2000/svg"
  >
    <title>Coolify</title>
    <path
      d="M18.8298 18.8316H7.28729V53.4593H18.8298V18.8316ZM18.8298 65.0018H65V53.4593H18.8298V65.0018ZM18.8298 18.8316H65V7.28906H18.8298V18.8316Z"
      fill="currentColor"
      fill-opacity="0.51"
    />
    <path
      d="M15.1862 15.1871H3.64368V49.8147H15.1862V15.1871ZM15.1862 61.3573H61.3564V49.8147H15.1862V61.3573ZM15.1862 15.1871H61.3564V3.64453H15.1862V15.1871Z"
      fill="#CCCCCC"
    />
    <path
      d="M11.5426 11.5426H0V46.1702H11.5426V11.5426ZM11.5426 57.7128H57.7128V46.1702H11.5426V57.7128ZM11.5426 11.5426H57.7128V0H11.5426V11.5426Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send email notifications using Coolify
  </Card>

  <Card
    title="Courrier"
    href="https://railsdesigner.com/courrier/"
    icon={
  <svg
    xmlns="http://www.w3.org/2000/svg"
    width="256"
    height="256"
    viewBox="0 0 256 256"
    className="h-6 w-6"
    fill="none"
  >
    <path
      fill="currentColor"
      d="M128 3c69.036 0 125 55.964 125 125s-55.964 125-125 125S3 197.036 3 128 58.964 3 128 3m.49 51q-16.204 0-29.679 5.485-13.379 5.485-23.271 15.51-9.799 10.024-15.17 23.736Q55 112.444 55 128.898q0 21.752 9.233 38.206t25.627 25.723Q106.255 202 127.831 202q12.343 0 22.989-3.404 10.741-3.406 21.67-10.876l7.537 12.294H187v-51.918h-8.386q-1.224 6.903-3.674 12.861-2.356 5.863-5.653 10.497-6.218 9.173-15.546 14.186-9.233 5.011-20.728 5.011-20.823 0-31.846-16.265-10.93-16.36-10.93-47.379 0-30.83 10.93-46.339 11.024-15.604 32.6-15.604 11.682 0 20.633 4.824 8.951 4.727 15.453 14.846 2.355 3.5 4.334 7.755 2.072 4.255 3.957 9.268H187v-45.77h-5.653l-8.103 9.55h-.754q-9.139-5.58-20.727-8.51Q140.173 54 128.49 54"
    ></path>
  </svg>
}
  >
    API-powered email delivery for Ruby apps
  </Card>

  <Card
    title="Kinde"
    href="https://docs.kinde.com/integrate/third-party-tools/kinde-resend-custom-smtp/"
    icon={
  <svg className="h-6 w-6" fill="none" viewBox="0 0 24 24">
    <path
      d="M 12.93 24 L 3.77 12.29 L 3.77 24 L 0 24 L 0 0 L 3.77 0 L 3.77 11.37 L 12.58 0 L 17.01 0 L 7.82 11.66 L 17.66 24 L 12.93 24 Z"
      fill="currentColor"
    />
  </svg>
}
  >
    Send auth and billing emails using Kinde
  </Card>
</CardGroup>

## Build your own integration

Here's how to build your own integration with Resend:

1. Read the documentation on [how to send emails](/api-reference/emails/send-email).
2. Integrate with your product offering.
3. [Reach out to us](https://resend.com/contact) to feature your product on this page.


# Introduction
Source: https://resend.com/docs/introduction

Resend is the email API for developers.

## Quickstart

Learn how to get Resend set up in your project.

<CardGroup>
  <Card
    title="Node.js Quickstart"
    icon={
<svg
  className="h-6 w-6"
  fill="currentcolor"
  height="40"
  viewBox="0 0 16 16"
  width="40"
  xmlns="http://www.w3.org/2000/svg"
>
  <path d="M 8 1.0234375 C 7.736875 1.0234375 7.4742344 1.0924687 7.2402344 1.2304688 L 2.7402344 3.8789062 C 2.2832344 4.1469063 2 4.642875 2 5.171875 L 2 11.005859 C 2 11.554859 2.29925 12.059266 2.78125 12.322266 L 4.2558594 13.126953 C 4.4828594 13.250953 4.7286094 13.310547 4.9746094 13.310547 C 5.2386094 13.310547 5.4992812 13.239609 5.7382812 13.099609 C 6.1982812 12.826609 6.4726562 12.344594 6.4726562 11.808594 L 6.4726562 5.4648438 L 5.4726562 5.4648438 L 5.4726562 11.808594 C 5.4726562 12.065594 5.3025156 12.195281 5.2285156 12.238281 C 5.1555156 12.281281 4.959375 12.371047 4.734375 12.248047 L 3.2617188 11.445312 C 3.1007187 11.357312 3 11.188859 3 11.005859 L 3 5.171875 C 3 4.995875 3.0940938 4.8302344 3.2460938 4.7402344 L 7.7460938 2.0917969 C 7.9020937 1.9997969 8.0979062 2.0007969 8.2539062 2.0917969 L 12.753906 4.7402344 C 12.904906 4.8302344 13 4.995875 13 5.171875 L 13 11.009766 C 13 11.189766 12.900234 11.359219 12.740234 11.449219 L 8.2402344 13.900391 C 8.0902344 13.980391 7.9097656 13.980391 7.7597656 13.900391 L 6.8808594 13.419922 C 6.7108594 13.629922 6.5 13.810937 6.25 13.960938 C 6.17 14.010938 6.0897656 14.050078 6.0097656 14.080078 L 7.2792969 14.779297 C 7.5092969 14.899297 7.75 14.960938 8 14.960938 C 8.25 14.960938 8.4907031 14.899297 8.7207031 14.779297 L 13.220703 12.320312 C 13.700703 12.060313 14 11.559766 14 11.009766 L 14 5.171875 C 14 4.642875 13.717719 4.1469062 13.261719 3.8789062 L 8.7617188 1.2304688 C 8.5272187 1.0924688 8.263125 1.0234375 8 1.0234375 z M 9.4511719 5.3183594 C 7.8711719 5.3183594 7.0703125 5.8690781 7.0703125 6.9550781 C 7.0703125 8.1850781 8.4869687 8.3680781 9.1679688 8.4550781 C 9.2659688 8.4680781 9.352875 8.4791875 9.421875 8.4921875 L 9.7207031 8.5449219 C 10.760703 8.7189219 11 8.836875 11 9.171875 C 11 9.333875 10.999172 9.8242188 9.4511719 9.8242188 C 8.1381719 9.8242188 7.8691406 9.4346094 7.8691406 8.8496094 L 6.8691406 8.8496094 C 6.8691406 9.7516094 7.3171719 10.824219 9.4511719 10.824219 C 11.557172 10.824219 12 9.925875 12 9.171875 C 12 7.913875 10.777719 7.7076406 9.8867188 7.5566406 L 9.5996094 7.5078125 C 9.5166094 7.4928125 9.4119219 7.4788438 9.2949219 7.4648438 C 8.6589219 7.3828438 8.0703125 7.2650312 8.0703125 6.9570312 C 8.0703125 6.7340313 8.0691719 6.3193594 9.4511719 6.3183594 C 10.370172 6.3183594 10.837891 6.6207969 10.837891 7.2167969 L 11.837891 7.2167969 C 11.837891 6.2997969 11.209172 5.3183594 9.4511719 5.3183594 z" />
</svg>
}
    href="/send-with-nodejs"
  />

  <Card
    title="Next.js Quickstart"
    icon={
<svg
  className="h-6 w-6"
  height="1024pt"
  viewBox=".5 -.2 1023 1024.1"
  width="1024pt"
  xmlns="http://www.w3.org/2000/svg"
>
  <path d="m478.5.6c-2.2.2-9.2.9-15.5 1.4-145.3 13.1-281.4 91.5-367.6 212-48 67-78.7 143-90.3 223.5-4.1 28.1-4.6 36.4-4.6 74.5s.5 46.4 4.6 74.5c27.8 192.1 164.5 353.5 349.9 413.3 33.2 10.7 68.2 18 108 22.4 15.5 1.7 82.5 1.7 98 0 68.7-7.6 126.9-24.6 184.3-53.9 8.8-4.5 10.5-5.7 9.3-6.7-.8-.6-38.3-50.9-83.3-111.7l-81.8-110.5-102.5-151.7c-56.4-83.4-102.8-151.6-103.2-151.6-.4-.1-.8 67.3-1 149.6-.3 144.1-.4 149.9-2.2 153.3-2.6 4.9-4.6 6.9-8.8 9.1-3.2 1.6-6 1.9-21.1 1.9h-17.3l-4.6-2.9c-3-1.9-5.2-4.4-6.7-7.3l-2.1-4.5.2-200.5.3-200.6 3.1-3.9c1.6-2.1 5-4.8 7.4-6.1 4.1-2 5.7-2.2 23-2.2 20.4 0 23.8.8 29.1 6.6 1.5 1.6 57 85.2 123.4 185.9s157.2 238.2 201.8 305.7l81 122.7 4.1-2.7c36.3-23.6 74.7-57.2 105.1-92.2 64.7-74.3 106.4-164.9 120.4-261.5 4.1-28.1 4.6-36.4 4.6-74.5s-.5-46.4-4.6-74.5c-27.8-192.1-164.5-353.5-349.9-413.3-32.7-10.6-67.5-17.9-106.5-22.3-9.6-1-75.7-2.1-84-1.3zm209.4 309.4c4.8 2.4 8.7 7 10.1 11.8.8 2.6 1 58.2.8 183.5l-.3 179.8-31.7-48.6-31.8-48.6v-130.7c0-84.5.4-132 1-134.3 1.6-5.6 5.1-10 9.9-12.6 4.1-2.1 5.6-2.3 21.3-2.3 14.8 0 17.4.2 20.7 2z" />
  <path d="m784.3 945.1c-3.5 2.2-4.6 3.7-1.5 2 2.2-1.3 5.8-4 5.2-4.1-.3 0-2 1-3.7 2.1zm-6.9 4.5c-1.8 1.4-1.8 1.5.4.4 1.2-.6 2.2-1.3 2.2-1.5 0-.8-.5-.6-2.6 1.1zm-5 3c-1.8 1.4-1.8 1.5.4.4 1.2-.6 2.2-1.3 2.2-1.5 0-.8-.5-.6-2.6 1.1zm-5 3c-1.8 1.4-1.8 1.5.4.4 1.2-.6 2.2-1.3 2.2-1.5 0-.8-.5-.6-2.6 1.1zm-7.6 4c-3.8 2-3.6 2.8.2.9 1.7-.9 3-1.8 3-2 0-.7-.1-.6-3.2 1.1z" />
</svg>
}
    href="/send-with-nextjs"
  />

  <Card
    title="Express Quickstart"
    icon={
<svg
  className="h-6 w-6"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="0 0 32 32"
  width="64"
  height="64"
>
  <path d="M32 24.795c-1.164.296-1.884.013-2.53-.957l-4.594-6.356-.664-.88-5.365 7.257c-.613.873-1.256 1.253-2.4.944l6.87-9.222-6.396-8.33c1.1-.214 1.86-.105 2.535.88l4.765 6.435 4.8-6.4c.615-.873 1.276-1.205 2.38-.883l-2.48 3.288-3.36 4.375c-.4.5-.345.842.023 1.325L32 24.795zM.008 15.427l.562-2.764C2.1 7.193 8.37 4.92 12.694 8.3c2.527 1.988 3.155 4.8 3.03 7.95H1.48c-.214 5.67 3.867 9.092 9.07 7.346 1.825-.613 2.9-2.042 3.438-3.83.273-.896.725-1.036 1.567-.78-.43 2.236-1.4 4.104-3.45 5.273-3.063 1.75-7.435 1.184-9.735-1.248C1 21.6.434 19.812.18 17.9c-.04-.316-.12-.617-.18-.92q.008-.776.008-1.552zm1.498-.38h12.872c-.084-4.1-2.637-7.012-6.126-7.037-3.83-.03-6.58 2.813-6.746 7.037z" />
</svg>
}
    href="send-with-express/"
  />

  <Card
    title="PHP Quickstart"
    icon={
<svg
  className="h-6 w-6 overflow-visible ml-1"
  fill="currentcolor"
  viewBox="0 0 16 16"
  xmlns="http://www.w3.org/2000/svg"
>
  <path
    clipRule="evenodd"
    d="M7.9999 13.6496C10.5698 13.6496 12.9461 13.1038 14.7162 12.1728C16.44 11.2661 17.8399 9.84028 17.8399 8.00001C17.8399 6.15974 16.44 4.73389 14.7162 3.82722C12.9461 2.89617 10.5698 2.35043 7.9999 2.35043C5.42997 2.35043 3.05373 2.89617 1.28358 3.82722C-0.440229 4.73389 -1.84009 6.15974 -1.84009 8.00001C-1.84009 9.84028 -0.440229 11.2661 1.28358 12.1728C3.05373 13.1038 5.42997 13.6496 7.9999 13.6496ZM16.8399 8.00001C16.8399 10.5679 12.8821 12.6496 7.9999 12.6496C3.11771 12.6496 -0.840088 10.5679 -0.840088 8.00001C-0.840088 5.43212 3.11771 3.35043 7.9999 3.35043C12.8821 3.35043 16.8399 5.43212 16.8399 8.00001ZM6.87738 4.72751C6.88194 4.70401 6.90252 4.68703 6.92646 4.68703H7.9244C7.93933 4.68703 7.95347 4.6937 7.96297 4.70522C7.97247 4.71674 7.97633 4.7319 7.97348 4.74655L7.7477 5.91034C7.84026 5.91005 7.9323 5.90915 8.02328 5.90826C8.33164 5.90523 8.62788 5.90233 8.89109 5.9236C9.24813 5.95245 9.55863 6.02638 9.76423 6.216C9.87161 6.31473 9.94117 6.42259 9.97569 6.5654C10.0097 6.70601 10.0089 6.87748 9.98244 7.10232C9.94727 7.40106 9.8651 7.80454 9.74965 8.37142L9.74964 8.37145L9.74963 8.3715C9.69183 8.65534 9.62568 8.98014 9.55291 9.35328C9.54833 9.37676 9.52775 9.39371 9.50383 9.39371H8.49295C8.47802 9.39371 8.46387 9.38704 8.45437 9.37552C8.44488 9.364 8.44102 9.34884 8.44386 9.33419C8.52282 8.92716 8.58966 8.5905 8.64516 8.31095L8.6452 8.31076C8.73782 7.8442 8.79885 7.53677 8.83193 7.32694C8.85847 7.15866 8.86601 7.05871 8.85915 6.99197C8.85276 6.92984 8.83413 6.8978 8.80269 6.8641L8.80265 6.86405C8.74366 6.80064 8.64179 6.76909 8.43806 6.75735C8.30039 6.74942 8.12483 6.75064 7.89766 6.75222H7.89756C7.80294 6.75288 7.69936 6.7536 7.58584 6.75374L7.07911 9.35328C7.07453 9.37676 7.05396 9.39371 7.03003 9.39371H6.03318C6.01825 9.39371 6.0041 9.38704 5.9946 9.37552C5.9851 9.36401 5.98125 9.34885 5.98409 9.33419L6.87738 4.72751ZM2.69684 5.95416C2.7014 5.93065 2.72198 5.91368 2.74593 5.91368H4.67706C5.26358 5.91368 5.70732 6.06602 5.98566 6.3872L5.94796 6.42002L5.98574 6.38729L5.98566 6.3872C6.25284 6.69412 6.33382 7.1487 6.26023 7.60473C6.18652 8.06151 5.95682 8.52755 5.59142 8.86359C5.00271 9.41486 4.36602 9.40924 3.44999 9.40117C3.34805 9.40027 3.24265 9.39934 3.13347 9.39914L2.90398 10.5831C2.89942 10.6066 2.87884 10.6236 2.85489 10.6236H1.85156C1.83663 10.6236 1.82249 10.6169 1.81299 10.6054C1.80349 10.5939 1.79963 10.5787 1.80248 10.5641L2.69684 5.95416ZM10.5358 5.95415C10.5403 5.93065 10.5609 5.91368 10.5848 5.91368H12.5171C13.1036 5.91368 13.5473 6.06602 13.8256 6.3872L13.788 6.42003L13.8257 6.38729L13.8256 6.3872C14.0928 6.69412 14.1738 7.1487 14.1002 7.60473C14.0265 8.06152 13.7968 8.52756 13.4314 8.86361C12.8466 9.41043 12.238 9.4066 11.2662 9.40048H11.2662H11.2662H11.2662H11.2661C11.1721 9.39988 11.0746 9.39927 10.9735 9.39913L10.744 10.5831C10.7394 10.6066 10.7188 10.6236 10.6949 10.6236H9.68939C9.67446 10.6236 9.66031 10.6169 9.65081 10.6054C9.64131 10.5939 9.63746 10.5787 9.64031 10.5641L10.5358 5.95415ZM3.65348 6.74077L3.29849 8.56995C3.36057 8.57023 3.42151 8.5709 3.48133 8.57155H3.48135H3.48137H3.48138H3.4814C3.6276 8.57314 3.76717 8.57465 3.90059 8.57041C4.10547 8.56389 4.28973 8.54381 4.4503 8.49113C4.60986 8.43878 4.7459 8.35429 4.85535 8.21803C4.96524 8.08121 5.05079 7.88912 5.10374 7.61781C5.17864 7.22899 5.12314 7.02269 4.9944 6.90717C4.92839 6.84793 4.83845 6.80787 4.72385 6.78174C4.60919 6.7556 4.47305 6.74411 4.31748 6.73973C4.1854 6.736 4.04245 6.73745 3.88872 6.739H3.88871H3.88869H3.88868H3.88866L3.88856 6.739C3.81282 6.73977 3.73445 6.74056 3.65348 6.74077ZM11.4902 6.74077L11.1352 8.56998C11.2034 8.57036 11.2702 8.57129 11.3358 8.57221C11.471 8.57409 11.601 8.57591 11.7268 8.57265C11.9303 8.56738 12.1151 8.54876 12.2771 8.49702C12.438 8.4456 12.5762 8.36154 12.6876 8.22455C12.7995 8.08703 12.8869 7.89302 12.9405 7.61781C13.0154 7.22882 12.9608 7.02253 12.8329 6.90707C12.7674 6.8479 12.6779 6.80786 12.5636 6.78174C12.4493 6.7556 12.3132 6.74411 12.1575 6.73973C12.0252 6.736 11.8816 6.73745 11.727 6.739L11.7268 6.739H11.7268H11.7268H11.7268C11.6506 6.73977 11.5717 6.74056 11.4902 6.74077Z"
    fillRule="evenodd"
  ></path>
</svg>
}
    href="send-with-php/"
  />

  <Card
    title="Laravel Quickstart"
    icon={
<svg
  className="h-6 w-6"
  fill="none"
  height="40"
  viewBox="0 0 16 16"
  width="40"
  xmlns="http://www.w3.org/2000/svg"
>
  <path
    d="M6.69141 2.76562L4.07422 4.27344M6.69141 2.76562L4.07422 1.25781L1.46094 2.76562M6.69141 2.76562V8.74242M4.07422 4.27344L1.46094 2.76562M4.07422 4.27344V10.2397M1.46094 2.76562V11.7266L6.69141 14.7422M6.69141 14.7422V11.7266M6.69141 14.7422L11.9201 11.7266V8.74242M6.69141 11.7266L4.07422 10.2397M6.69141 11.7266L11.9201 8.74242M4.07422 10.2397L6.69141 8.74242M9.31189 4.27344L11.9201 2.76562L14.5365 4.27344M9.31189 4.27344L11.9201 5.77934M9.31189 4.27344V7.24025M11.9201 5.77934L14.5365 4.27344M11.9201 5.77934V8.74242M14.5365 4.27344V7.24025L11.9201 8.74242M11.9201 8.74242L9.31189 7.24025M9.31189 7.24025L6.69141 8.74242"
    stroke="currentcolor"
    strokeLinecap="round"
    strokeLinejoin="round"
    strokeWidth="0.9"
  ></path>
</svg>
}
    href="send-with-laravel/"
  />

  <Card
    title="Python Quickstart"
    icon={
<svg
  className="h-6 w-6"
  fill="currentcolor"
  height="40"
  viewBox="0 0 16 16"
  width="40"
  xmlns="http://www.w3.org/2000/svg"
>
  <path
    clipRule="evenodd"
    d="M5.00008 2.48333C5.00008 2.28791 5.17329 1.97181 5.75348 1.67407C6.30368 1.39174 7.09756 1.2 8.00008 1.2C8.9026 1.2 9.69648 1.39174 10.2467 1.67407C10.8269 1.97181 11.0001 2.28791 11.0001 2.48333L11 4.49999V4.66666C11 5.4877 10.9478 6.0615 10.8418 6.46743C10.7387 6.86203 10.595 7.06047 10.4316 7.18155C10.2553 7.31215 9.98982 7.40251 9.54728 7.45087C9.10384 7.49934 8.5515 7.5 7.83337 7.5H7.80801C7.20363 7.49999 6.65752 7.49998 6.19769 7.55571C5.72755 7.6127 5.28198 7.73413 4.91686 8.02623C4.54439 8.32421 4.31834 8.74858 4.18424 9.28498C4.06996 9.74209 4.01556 10.3077 4.00296 11H2.48341C2.28799 11 1.97188 10.8268 1.67415 10.2466C1.39181 9.6964 1.20007 8.90252 1.20007 8C1.20007 7.09748 1.39181 6.3036 1.67415 5.7534C1.97188 5.17321 2.28799 5 2.48341 5H4.50008H8.00007V4H5.00008V2.48333ZM2.48341 12H4.00005L4.00008 13.5167C4.00008 14.2877 4.61037 14.8633 5.29693 15.2156C6.01348 15.5833 6.9696 15.8 8.00008 15.8C9.03056 15.8 9.98668 15.5833 10.7032 15.2156C11.3898 14.8633 12.0001 14.2877 12.0001 13.5167V12H13.5167C14.2878 12 14.8634 11.3897 15.2157 10.7031C15.5834 9.9866 15.8001 9.03048 15.8001 8C15.8001 6.96952 15.5834 6.0134 15.2157 5.29685C14.8634 4.61029 14.2878 4 13.5167 4H12.0001L12.0001 2.48334C12.0001 1.71225 11.3898 1.13669 10.7032 0.784379C9.98668 0.416675 9.03056 0.199997 8.00008 0.199997C6.9696 0.199997 6.01348 0.416675 5.29693 0.784379C4.61037 1.13669 4.00008 1.71225 4.00008 2.48333V4H2.48341C1.71232 4 1.13677 4.61029 0.784455 5.29685C0.416751 6.0134 0.200073 6.96952 0.200073 8C0.200073 9.03048 0.416751 9.9866 0.784455 10.7031C1.13677 11.3897 1.71232 12 2.48341 12ZM8.00007 12H11.0001V13.5167C11.0001 13.7121 10.8269 14.0282 10.2467 14.3259C9.69648 14.6083 8.9026 14.8 8.00008 14.8C7.09756 14.8 6.30368 14.6083 5.75348 14.3259C5.17329 14.0282 5.00008 13.7121 5.00008 13.5167L5.00004 11.5L5.00004 11.5L5.00004 11.3333C5.00004 10.5132 5.05211 9.93659 5.15438 9.52752C5.25466 9.12641 5.39319 8.92579 5.54155 8.8071C5.69727 8.68253 5.92878 8.59563 6.31802 8.54845C6.71114 8.5008 7.19784 8.5 7.83337 8.5H7.85761C8.54613 8.50001 9.15215 8.50001 9.65592 8.44495C10.1665 8.38915 10.6406 8.27118 11.0268 7.98511C11.4259 7.68952 11.6676 7.26296 11.8093 6.72007C11.9294 6.26027 11.9844 5.69226 11.9971 5H13.5167C13.7122 5 14.0283 5.17321 14.326 5.7534C14.6083 6.3036 14.8001 7.09748 14.8001 8C14.8001 8.90252 14.6083 9.6964 14.326 10.2466C14.0283 10.8268 13.7122 11 13.5167 11H11.5001H8.00007V12ZM6.2262 3.45245C6.57205 3.45245 6.85242 3.17208 6.85242 2.82622C6.85242 2.48037 6.57205 2.2 6.2262 2.2C5.88035 2.2 5.59998 2.48037 5.59998 2.82622C5.59998 3.17208 5.88035 3.45245 6.2262 3.45245ZM9.77725 13.8045C10.1237 13.8045 10.4045 13.5237 10.4045 13.1773C10.4045 12.8308 10.1237 12.55 9.77725 12.55C9.43083 12.55 9.15 12.8308 9.15 13.1773C9.15 13.5237 9.43083 13.8045 9.77725 13.8045Z"
    fillRule="evenodd"
  ></path>
</svg>
}
    href="/send-with-python"
  />

  <Card
    title="Ruby Quickstart"
    icon={
<svg
  className="h-6 w-6"
  fill="currentcolor"
  height="40"
  viewBox="0 0 16 16"
  width="40"
  xmlns="http://www.w3.org/2000/svg"
>
  <path d="M 7.992188 1 C 7.917969 1 7.84375 1.019531 7.777344 1.054688 L 4.777344 2.554688 C 4.730469 2.578125 4.683594 2.609375 4.648438 2.648438 L 2.648438 4.648438 C 2.617188 4.675781 2.589844 4.707031 2.570313 4.742188 L 1.070313 7.242188 C 1.023438 7.320313 1 7.410156 1 7.5 C 1 7.507813 1 7.519531 1 7.53125 L 1 11.5 C 1 11.628906 1.050781 11.757813 1.140625 11.847656 C 1.238281 12.371094 1.375 12.890625 1.742188 13.257813 C 2.3125 13.828125 3.109375 14.027344 4 13.976563 L 4 14 L 14 14 L 14 5.539063 C 14 5.511719 14 5.484375 14 5.460938 L 14 3.5 L 13.992188 3.5 C 13.949219 2.8125 13.722656 2.207031 13.257813 1.742188 C 12.890625 1.375 12.371094 1.238281 11.847656 1.140625 C 11.753906 1.050781 11.628906 1 11.5 1 L 8 1 C 8 1 7.996094 1 7.992188 1 Z M 9.652344 2 L 11.40625 2 C 11.425781 2.003906 11.445313 2.007813 11.464844 2.007813 C 11.941406 2.042969 12.296875 2.195313 12.550781 2.449219 C 12.949219 2.84375 13.089844 3.539063 12.929688 4.445313 L 9.820313 2.117188 L 9.800781 2.101563 C 9.792969 2.09375 9.785156 2.089844 9.777344 2.085938 Z M 7.964844 2.078125 L 8.90625 2.703125 L 8.0625 5.230469 L 5.257813 8.03125 L 2.734375 8.453125 L 2.09375 7.484375 L 3.398438 5.3125 L 5.296875 3.410156 Z M 9.757813 3.316406 L 12 5 L 9.195313 5 Z M 9.238281 6 L 12.410156 6 C 11.980469 6.960938 11.3125 7.988281 10.4375 8.992188 Z M 8.316406 6.390625 L 9.601563 9.601563 L 6.390625 8.316406 Z M 13 7.078125 L 13 12.292969 L 10.925781 10.21875 L 10.847656 10.023438 C 11.742188 9.0625 12.472656 8.0625 13 7.078125 Z M 4.9375 9.101563 L 4.660156 11.859375 L 3.28125 9.375 Z M 2 9.152344 L 2.070313 9.257813 L 4.125 12.957031 C 3.382813 13.03125 2.796875 12.898438 2.449219 12.550781 C 2.449219 12.550781 2.449219 12.550781 2.445313 12.550781 C 2.191406 12.296875 2.042969 11.945313 2.007813 11.464844 C 2.007813 11.441406 2.003906 11.421875 2 11.40625 Z M 5.929688 9.210938 L 8.992188 10.4375 C 7.847656 11.433594 6.660156 12.171875 5.59375 12.585938 Z M 10.023438 10.847656 L 10.21875 10.925781 L 12.292969 13 L 7.078125 13 C 8.0625 12.472656 9.0625 11.742188 10.023438 10.847656 Z" />
</svg>
}
    href="/send-with-ruby"
  />

  <Card
    title="Rails Quickstart"
    icon={
<svg
  className="h-6 w-6"
  fill="currentcolor"
  width="14"
  height="10"
  viewBox="0 0 14 10"
  xmlns="http://www.w3.org/2000/svg"
>
  <path
    fillRule="evenodd"
    clipRule="evenodd"
    d="M9.26954 1.31918C8.74765 1.18951 8.22291 1.12537 7.70403 1.12123L7.70802 0.621251C8.26552 0.625698 8.8294 0.694622 9.3901 0.833934L9.26954 1.31918ZM6.1341 1.29217C5.61738 1.40973 5.1165 1.5859 4.64137 1.81461L4.42451 1.36409C4.9329 1.11936 5.46929 0.930647 6.02318 0.804633L6.1341 1.29217ZM11.4358 2.2739C11.2094 2.12558 10.98 1.99259 10.7486 1.87436L10.976 1.42909C11.2236 1.55556 11.4685 1.69759 11.7098 1.85567L12.0666 2.08946L11.7926 2.50769L11.4358 2.2739ZM3.30044 2.65449C2.88728 2.98213 2.51016 3.35589 2.17885 3.76948L1.78862 3.45688C2.14375 3.01354 2.54767 2.61332 2.98975 2.26273L3.30044 2.65449ZM12.8631 3.20907L12.5063 2.97527L12.7803 2.55704L13.1371 2.79084L12.8631 3.20907ZM1.33981 5.10736C1.11705 5.57601 0.945725 6.07612 0.834598 6.60227L0.34539 6.49894C0.464781 5.93367 0.648893 5.39625 0.888228 4.89272L1.33981 5.10736ZM0.688533 8.1753C0.693883 8.43516 0.713433 8.69954 0.748067 8.96796L0.252178 9.03194C0.215265 8.74586 0.194362 8.46356 0.188639 8.18559L0.688533 8.1753ZM13.0001 4.99995L11.8648 4.46569C8.7923 3.0198 5.37433 5.6624 6.00012 8.99995H1.50012C0.752281 3.39114 7.11327 -0.36068 11.6602 3.00738L13.0001 3.99995V4.99995ZM9.39343 5.36218C9.65957 5.28953 9.9379 5.25342 10.2218 5.25912L10.2319 4.75922C9.89885 4.75254 9.57282 4.79491 9.26176 4.87982L9.39343 5.36218ZM11.0465 5.39477C11.1775 5.43577 11.3086 5.48648 11.4394 5.54749L11.8031 5.71725L12.0146 5.26415L11.6508 5.0944C11.5001 5.02407 11.3482 4.9653 11.1959 4.91761L11.0465 5.39477ZM7.97238 6.22066C8.16447 6.01612 8.38421 5.83825 8.62428 5.69298L8.36542 5.2652C8.08642 5.43403 7.83115 5.64067 7.60791 5.87838L7.97238 6.22066ZM12.5307 6.05675L12.8944 6.2265L13.1058 5.77341L12.7421 5.60365L12.5307 6.05675ZM7.21528 7.69283C7.26885 7.41392 7.36213 7.14921 7.48862 6.90405L7.04428 6.67479C6.89644 6.96135 6.78708 7.27139 6.72425 7.59851L7.21528 7.69283ZM7.24372 8.94374C7.21128 8.80315 7.189 8.6643 7.17618 8.52767L6.67837 8.57438C6.69328 8.73332 6.71913 8.89411 6.75653 9.05617L7.24372 8.94374Z"
    fill="currentcolor"
  />
</svg>
}
    href="/send-with-rails"
  />

  <Card
    title="Go Quickstart"
    icon={
<svg
  className="h-6 w-6"
  fill="currentcolor"
  height="40"
  style={{ overflow: 'visible' }}
  viewBox="0 0 16 16"
  width="40"
  xmlns="http://www.w3.org/2000/svg"
>
  <path
    clipRule="evenodd"
    d="M8.58088 6.38879C8.24298 6.47352 7.96479 6.54646 7.6815 6.62074L7.68145 6.62075C7.45577 6.67992 7.22686 6.73994 6.96195 6.80744L6.94603 6.81166C6.8165 6.84601 6.80299 6.84959 6.68249 6.71229C6.53794 6.55054 6.43194 6.44588 6.22957 6.35073C5.62247 6.05577 5.03464 6.1414 4.48536 6.49345C3.83008 6.9121 3.4928 7.53056 3.50244 8.30126C3.51208 9.06244 4.04208 9.69042 4.80337 9.79508C5.45865 9.88072 6.00793 9.65236 6.44157 9.1671C6.50586 9.08953 6.56485 9.00671 6.63032 8.91481L6.63033 8.91479L6.63041 8.91468C6.65324 8.88263 6.67685 8.84948 6.70176 8.81506H4.84191C4.63955 8.81506 4.59136 8.69136 4.65882 8.52961C4.7841 8.23466 5.01537 7.73989 5.15028 7.4925C5.17919 7.43541 5.24665 7.34027 5.39119 7.34027H8.49247C8.63176 6.90459 8.85774 6.49291 9.15917 6.10338C9.86263 5.18996 10.7106 4.71423 11.8574 4.51441C12.8403 4.34315 13.7654 4.4383 14.6038 4.99967C15.365 5.51347 15.8372 6.20805 15.9625 7.12147C16.1263 8.40596 15.7505 9.45259 14.8543 10.3469C14.2183 10.9844 13.4377 11.384 12.5415 11.5648C12.3708 11.5961 12.1999 11.6109 12.0318 11.6255C11.9439 11.6331 11.8567 11.6407 11.7706 11.6505C10.8937 11.6314 10.0939 11.384 9.41935 10.8132C8.94488 10.4082 8.61806 9.91052 8.45568 9.33109C8.34297 9.55585 8.2082 9.7711 8.05087 9.97586C7.35704 10.8798 6.45121 11.4411 5.30447 11.5934C4.36009 11.7171 3.48317 11.5363 2.71225 10.9654C1.99914 10.4326 1.59441 9.72849 1.48841 8.85312C1.36314 7.816 1.6715 6.88356 2.30751 6.06528C2.9917 5.18041 3.89754 4.61904 5.00573 4.41923C5.91157 4.25748 6.77885 4.36214 7.55941 4.88545C8.07014 5.21847 8.43633 5.67518 8.67724 6.22704C8.73506 6.31267 8.69652 6.36024 8.58088 6.38879ZM-2.29935 6.56005C-2.33789 6.56005 -2.34753 6.54102 -2.32826 6.51248L-2.12589 6.25558C-2.10662 6.22704 -2.05844 6.20801 -2.01989 6.20801H1.42034C1.45889 6.20801 1.46853 6.23655 1.44925 6.2651L1.28543 6.51248C1.26616 6.54102 1.21798 6.56957 1.18907 6.56957L-2.29935 6.56005ZM-3.75442 7.43554C-3.79297 7.43554 -3.8026 7.41651 -3.78333 7.38797L-3.58096 7.13107C-3.56169 7.10253 -3.51351 7.0835 -3.47496 7.0835H0.919281C0.957828 7.0835 0.977101 7.11204 0.967464 7.14059L0.890373 7.36894C0.880736 7.407 0.84219 7.42603 0.803644 7.42603L-3.75442 7.43554ZM-1.4513 8.2537C-1.47057 8.28224 -1.46093 8.31078 -1.42239 8.31078L0.678369 8.3203C0.707278 8.3203 0.745825 8.29175 0.745825 8.2537L0.765097 8.02534C0.765097 7.98728 0.745825 7.95874 0.707279 7.95874H-1.22002C-1.25856 7.95874 -1.29711 7.98728 -1.31638 8.01583L-1.4513 8.2537ZM14.0575 7.70514C14.0594 7.73699 14.0613 7.77055 14.0641 7.80653C14.0159 8.6248 13.6016 9.23375 12.8403 9.62385C12.3295 9.88075 11.7995 9.9093 11.2695 9.68094C10.5757 9.37647 10.2095 8.6248 10.383 7.88265C10.595 6.98826 11.1732 6.42689 12.0694 6.22708C12.9848 6.01775 13.8617 6.55058 14.0352 7.49254C14.0489 7.56001 14.0529 7.62749 14.0575 7.70514Z"
    fillRule="evenodd"
  ></path>
</svg>
}
    href="/send-with-go"
  />

  <Card
    title="Rust Quickstart"
    icon={
<svg
  fill="currentcolor"
  xmlns="http://www.w3.org/2000/svg"
  viewBox="4 4 16 16"
>
  <path
    d="m19.89 11.804-.671-.416a9.793 9.793 0 0 0-.019-.195l.577-.539a.23.23 0 0 0-.077-.386l-.738-.276a8.96 8.96 0 0 0-.057-.19l.46-.64a.231.231 0 0 0-.15-.363l-.779-.126a5.871 5.871 0 0 0-.093-.175l.327-.718a.23.23 0 0 0-.105-.302.23.23 0 0 0-.114-.025l-.789.028a6.455 6.455 0 0 0-.125-.151l.181-.77a.23.23 0 0 0-.277-.278l-.77.181-.151-.125.027-.789a.231.231 0 0 0-.212-.24.23.23 0 0 0-.114.022l-.718.327a8.455 8.455 0 0 0-.175-.094l-.127-.778a.23.23 0 0 0-.363-.15l-.64.459a7.18 7.18 0 0 0-.19-.057l-.275-.738a.23.23 0 0 0-.386-.077l-.538.578a6.308 6.308 0 0 0-.196-.02l-.416-.671a.23.23 0 0 0-.393 0l-.416.672a6.46 6.46 0 0 0-.195.019l-.539-.578a.232.232 0 0 0-.386.077l-.275.738a7.035 7.035 0 0 0-.19.058l-.64-.461a.23.23 0 0 0-.364.15l-.127.779c-.058.03-.116.062-.175.094L7.78 5.33a.23.23 0 0 0-.327.218l.028.79a7.17 7.17 0 0 0-.152.125l-.769-.182a.232.232 0 0 0-.278.278l.181.77-.125.15-.79-.027a.231.231 0 0 0-.218.327l.327.718a7.192 7.192 0 0 0-.093.175l-.778.126a.231.231 0 0 0-.15.364l.459.639c-.02.063-.039.127-.057.19l-.738.276a.231.231 0 0 0-.077.386l.578.539c-.008.065-.014.13-.02.195l-.671.416a.23.23 0 0 0 0 .393l.671.416c.006.065.012.13.02.196l-.578.538a.23.23 0 0 0 .077.386l.738.275c.018.065.038.128.058.19l-.461.64a.231.231 0 0 0 .15.363l.779.127c.03.059.061.117.094.175l-.328.717a.231.231 0 0 0 .219.327l.789-.027.125.151-.181.77a.23.23 0 0 0 .278.277l.769-.18c.05.042.1.083.152.124l-.028.79a.23.23 0 0 0 .327.218l.718-.327c.057.032.116.063.175.094l.126.777a.23.23 0 0 0 .364.151l.639-.46c.063.02.127.04.19.057l.276.738a.23.23 0 0 0 .385.077l.54-.578c.065.008.13.014.195.02l.416.672a.231.231 0 0 0 .393 0l.416-.672a6.34 6.34 0 0 0 .196-.02l.538.578a.23.23 0 0 0 .385-.077l.277-.738a6.39 6.39 0 0 0 .19-.058l.64.461a.23.23 0 0 0 .316-.044.233.233 0 0 0 .046-.107l.127-.778c.059-.03.117-.062.175-.093l.718.327a.23.23 0 0 0 .326-.219l-.027-.79c.051-.04.102-.081.152-.124l.768.181a.229.229 0 0 0 .276-.16.23.23 0 0 0 .002-.117l-.18-.77.124-.151.79.027a.23.23 0 0 0 .218-.327l-.327-.717c.032-.058.063-.116.093-.175l.779-.127a.229.229 0 0 0 .193-.254.23.23 0 0 0-.043-.109l-.46-.64c.02-.063.039-.126.057-.19l.738-.275a.23.23 0 0 0 .077-.386l-.578-.538.02-.196.671-.416a.231.231 0 0 0 0-.393Zm-4.495 5.572a.476.476 0 0 1 .2-.93.476.476 0 0 1-.2.93Zm-.229-1.544a.433.433 0 0 0-.514.333l-.238 1.113a5.824 5.824 0 0 1-2.414.52 5.83 5.83 0 0 1-2.464-.543l-.239-1.113a.433.433 0 0 0-.514-.333l-.982.21a5.829 5.829 0 0 1-.508-.598h4.78c.054 0 .09-.01.09-.059v-1.69c0-.05-.036-.06-.09-.06h-1.398V12.54h1.512c.138 0 .738.04.93.807.06.235.192 1.002.282 1.248.09.275.456.826.846.826h2.382a.484.484 0 0 0 .087-.009 5.808 5.808 0 0 1-.542.635l-1.006-.215Zm-6.611 1.52a.476.476 0 0 1-.2-.93.478.478 0 0 1 .568.552.476.476 0 0 1-.368.378ZM6.742 10a.475.475 0 1 1-.869.385.475.475 0 0 1 .869-.385Zm-.558 1.321 1.024-.454a.434.434 0 0 0 .22-.573l-.211-.476h.829v3.736H6.374a5.857 5.857 0 0 1-.19-2.233Zm4.491-.363V9.857h1.974c.103 0 .72.118.72.58 0 .383-.473.521-.864.521h-1.83Zm7.175.992c0 .146-.006.29-.017.434h-.6c-.06 0-.084.04-.084.099v.275c0 .649-.366.79-.686.826-.305.034-.644-.128-.686-.315-.18-1.013-.48-1.229-.954-1.603.588-.373 1.2-.924 1.2-1.661 0-.797-.546-1.298-.918-1.544a2.605 2.605 0 0 0-1.255-.413H7.643A5.842 5.842 0 0 1 10.915 6.2l.732.767c.165.173.44.18.612.014l.819-.783a5.856 5.856 0 0 1 4.005 2.852l-.561 1.266a.434.434 0 0 0 .22.572l1.08.48c.018.191.028.384.028.581Zm-6.203-6.402a.475.475 0 1 1 .656.686.475.475 0 0 1-.656-.686Zm5.562 4.475a.475.475 0 1 1 .868.386.475.475 0 0 1-.869-.386Z"
    fill="currentColor"
  />
</svg>
}
    href="/send-with-rust"
  />

  <Card
    title="Elixir Quickstart"
    icon={
<svg
  className="h-6 w-6"
  fill="currentcolor"
  height="40"
  viewBox="0 0 16 16"
  width="40"
  xmlns="http://www.w3.org/2000/svg"
>
  <path
    clipRule="evenodd"
    d="M8.95169 0.940326L8.97457 0.208954L8.28489 0.45342C7.07051 0.883867 5.99667 2.09398 5.02015 3.89315C4.30013 5.21975 3.4379 6.88892 3.09609 8.62234C2.75009 10.377 2.93069 12.2387 4.34004 13.8814C4.98953 14.6384 5.86559 15.2573 6.9497 15.5007C8.03868 15.7451 9.28923 15.5995 10.6621 14.9092C11.8527 14.3106 12.5834 13.1706 12.9194 12.0293C13.2515 10.9011 13.2298 9.66104 12.7781 8.8081C12.0293 7.39378 11.2718 6.47993 10.6584 5.73986L10.6584 5.73985L10.5548 5.61473C9.92016 4.84726 9.50366 4.30289 9.32552 3.53488C9.05065 2.34986 8.93437 1.49391 8.95169 0.940326ZM5.89904 4.37018C6.61644 3.04841 7.31909 2.19545 7.9882 1.72834C8.04627 2.2973 8.16963 2.97725 8.35138 3.76083C8.58889 4.78478 9.15631 5.49275 9.78417 6.252L9.88372 6.37222C10.4932 7.10777 11.1945 7.95414 11.8944 9.27603C12.1844 9.82388 12.2463 10.7747 11.9601 11.7469C11.6777 12.7059 11.0882 13.5757 10.2129 14.0158C9.01413 14.6185 7.99909 14.7113 7.16869 14.5249C6.33341 14.3375 5.6363 13.8565 5.09899 13.2303C3.943 11.8829 3.77243 10.3613 4.07719 8.81581C4.38614 7.24906 5.17662 5.70118 5.89904 4.37018ZM4.675 10.5227C4.81738 11.1996 5.12501 11.8571 5.64824 12.467C6.32801 13.2593 7.33535 13.8556 8.61589 13.7953L8.56887 12.7964C7.65729 12.8393 6.92974 12.4249 6.40719 11.8159C5.99411 11.3344 5.76156 10.8302 5.65359 10.3169L4.675 10.5227Z"
    fillRule="evenodd"
  ></path>
</svg>
}
    href="/send-with-elixir"
  />

  <Card
    title="Java Quickstart"
    icon={
<svg
  className="h-6 w-6"
  width="40"
  height="40"
  viewBox="0 0 40 40"
  fill="currentcolor"
  stroke="currentcolor"
  xmlns="http://www.w3.org/2000/svg"
>
  <g clipPath="url(#clip0_1059_8989)">
    <path
      d="M13.9627 29.3125C13.9627 29.3125 12.0795 30.5902 15.3029 31.0226C19.208 31.5424 21.2038 31.4679 25.5072 30.5176C25.5072 30.5176 26.6387 31.3453 28.2188 32.0622C18.5716 36.8862 6.38534 31.7828 13.9627 29.3125Z"
      strokeWidth="0.2"
      strokeLinejoin="round"
    />
    <path
      d="M13.9194 24.5625C13.9194 24.5625 12.0673 25.9582 14.8958 26.2561C18.5535 26.6403 21.442 26.6717 26.4403 25.6918C26.4403 25.6918 27.1317 26.4054 28.2187 26.7956C17.9915 29.8403 6.60026 27.0357 13.9194 24.5625Z"
      strokeWidth="0.2"
      strokeLinejoin="round"
    />
    <path
      d="M21.3193 16.5103C22.86 18.2484 20.9146 19.8125 20.9146 19.8125C20.9146 19.8125 24.8265 17.8336 23.0299 15.3555C21.352 13.0446 20.0652 11.8964 27.0312 7.9375C27.0312 7.9375 16.0969 10.6135 21.3193 16.5103Z"
      strokeWidth="0.2"
      strokeLinejoin="round"
    />
    <path
      d="M34.4522 33.2528C34.4522 33.2528 35.7597 34.2935 33.0122 35.0986C27.7878 36.6275 11.2676 37.0892 6.67835 35.1596C5.02864 34.4663 8.12232 33.5041 9.09547 33.3022C10.1104 33.0896 10.6904 33.1293 10.6904 33.1293C8.8557 31.8807 -1.16807 35.5808 5.59877 36.6404C24.0529 39.5315 39.239 35.3386 34.4522 33.2528Z"
      strokeWidth="0.2"
      strokeLinejoin="round"
    />
    <path
      d="M15.145 19.8191C15.145 19.8191 6.55287 21.5665 12.1023 22.201C14.4455 22.4697 19.1165 22.4089 23.4674 22.0967C27.0233 21.8399 30.5938 21.2938 30.5938 21.2938C30.5938 21.2938 29.3399 21.7536 28.4328 22.284C19.7076 24.2488 2.85216 23.3347 7.70463 21.3249C11.8084 19.6264 15.145 19.8191 15.145 19.8191Z"
      strokeWidth="0.2"
      strokeLinejoin="round"
    />
    <path
      d="M30.7628 27.9175C39.1741 23.7999 35.285 19.8429 32.5705 20.376C31.9052 20.5065 31.6085 20.6195 31.6085 20.6195C31.6085 20.6195 31.8555 20.255 32.3273 20.0973C37.6974 18.3187 41.8274 25.3429 30.5938 28.125C30.5938 28.125 30.7239 28.0155 30.7628 27.9175Z"
      strokeWidth="0.2"
      strokeLinejoin="round"
    />
    <path
      d="M22.6092 2C22.6092 2 25.9593 5.1498 19.4318 9.9933C14.1975 13.8786 18.2382 16.0939 19.4297 18.625C16.3743 16.034 14.132 13.7531 15.6363 11.6302C17.8442 8.51409 23.9609 7.00326 22.6092 2Z"
      strokeWidth="0.2"
      strokeLinejoin="round"
    />
    <path
      d="M15.8835 39.8818C24.3732 40.3152 37.41 39.6413 37.7187 36.4375C37.7187 36.4375 37.1252 37.652 30.7025 38.6166C23.4564 39.7042 14.5194 39.5772 9.21875 38.8802C9.21875 38.8802 10.3039 39.5964 15.8835 39.8818Z"
      strokeWidth="0.2"
      strokeLinejoin="round"
    />
  </g>
</svg>
}
    href="/send-with-java"
  />

  <Card
    title=".NET Quickstart"
    icon={
<svg
  fill="none"
  height={24}
  width={32}
  xmlns="http://www.w3.org/2000/svg"
  viewBox="69.65 171 323.05 120.35"
>
  <path
    d="M81.274 291.333c-3.224 0-5.965-1.074-8.222-3.223-2.257-2.204-3.386-4.821-3.386-7.851 0-3.086 1.129-5.73 3.386-7.934 2.257-2.204 4.998-3.306 8.222-3.306 3.278 0 6.045 1.102 8.302 3.306 2.311 2.204 3.466 4.848 3.466 7.934 0 3.03-1.155 5.647-3.466 7.851-2.257 2.149-5.024 3.223-8.302 3.223ZM210.167 289.515h-20.958l-55.215-87.109a38.977 38.977 0 0 1-3.466-6.86h-.484c.43 2.535.645 7.962.645 16.281v77.688h-18.54V171h22.328l53.362 85.043c2.257 3.527 3.708 5.951 4.353 7.273h.322c-.537-3.14-.806-8.457-.806-15.951V171h18.459v118.515ZM300.449 289.515h-64.888V171h62.309v16.695h-43.124v33.554h39.739v16.612h-39.739v35.042h45.703v16.612ZM392.667 187.695h-33.21v101.82h-19.185v-101.82h-33.129V171h85.524v16.695Z"
    fill="currentColor"
  />
</svg>
}
    href="/send-with-dotnet"
  />
</CardGroup>

## Explore

Discover the full range of features and capabilities.

<CardGroup>
  <Card title="Emails" href="dashboard/emails">
    Visualize all the activity in your account.
  </Card>

  <Card title="Domains" href="dashboard/domains/introduction">
    Ensure deliverability of your emails.
  </Card>

  <Card title="Webhooks" href="/webhooks/introduction">
    Notify your application about email events.
  </Card>
</CardGroup>


# 403 Error Using Verified Domain
Source: https://resend.com/docs/knowledge-base/403-error-domain-mismatch

Learn how to resolve a 403 error caused by using a domain in your API request that doesn't match your verified domain.

A 403 error can occur when there's a mismatch between the domain you're using in your API request and the domain you've verified in Resend.

## The Problem

You've verified a domain (or subdomain) in Resend, but your API request is using a different domain.

**Example scenario:**

* You verified `sending.domain.com` in Resend
* Your API request is using `domain.com` (i.e., without the `sending` subdomain)

## How to Identify This Issue

1. Check which domain you've verified in your [Resend Domains page](https://resend.com/domains).
2. Compare it with the domain you're using in [your API request's](https://resend.com/logs) `from` field.

## Solution

You have two options to resolve this:

**Option 1: Update your API request** (Recommended)

Update your API call to use the verified domain. For example, if you verified `sending.domain.com`, make sure your `from` field uses that exact domain:

```javascript theme={null}
resend.emails.send({
  from: 'onboarding@sending.domain.com', // Use your verified domain
  to: 'user@example.com',
  subject: 'Hello World',
  html: '<p>Hello World</p>',
});
```

**Option 2: Delete and re-add the domain**

1. Delete the domain you've added in Resend
2. Add and verify the domain that matches what you're using in your API request

<Warning>
  Make sure the domain in your API request exactly matches the domain you've
  verified in Resend, including any subdomains.
</Warning>

## Still Having Issues?

If you've verified that your domain matches and you're still getting a 403 error:

1. Verify that your domain is fully verified in the [Resend Domains page](https://resend.com/domains).
2. Double-check that the domain in your API request's `from` field exactly matches your verified domain
3. Ensure your API key has the necessary permissions.
4. [Contact Resend support](https://resend.com/help) with details about your error


# 403 Error Using resend.dev Domain
Source: https://resend.com/docs/knowledge-base/403-error-resend-dev-domain

Learn how to resolve a 403 error when using the resend.dev domain to send emails to recipients other than your own.

You may receive a 403 error with the following message when trying to send emails:

```
You can only send testing emails to your own email address (your-email-address@domain.com).
To send emails to other recipients, please verify a domain at resend.com/domains, and change
the `from` address to an email using this domain.
```

## The Problem

You're using the default `resend.dev` domain while sending to email addresses other than your own.

**Example scenario:**

* Your API request uses `from: 'onboarding@resend.dev'`
* You're trying to send to recipients other than your own email address

## Why This Happens

The `resend.dev` domain is only available for testing purposes and can only send emails to the email address associated with your Resend account. This restriction helps protect domain reputation and ensures proper email deliverability.

## Solution

To send emails to recipients other than your own email address, you need to add and verify your own domain in Resend:

1. Go to the [Domains page](https://resend.com/domains) in your Resend dashboard
2. Click **Add Domain**
3. Enter your domain name
4. Follow the verification steps to add the required DNS records
5. Once verified, update your API request to use your verified domain

<Info>
  For detailed instructions on verifying your domain, check out our [domain
  verification guide](/dashboard/domains/introduction) or the DNS guide for your
  specific provider.
</Info>

## Still Having Issues?

If you've verified your domain and updated your API request but you're still getting a 403 error:

1. Verify that your domain is fully verified in the [Resend Domains page](https://resend.com/domains).
2. Ensure the domain in your API request's `from` field uses your verified domain (not `resend.dev`).
3. Make sure you're not trying to send to your own email address when using `resend.dev`.
4. [Contact Resend support](https://resend.com/help) with details about your error.


# What are Resend account quotas and limits?
Source: https://resend.com/docs/knowledge-base/account-quotas-and-limits

Learn what quotas and limits apply to accounts.

Resend regulates email volume in three ways:

1. email volume (quota) - for [Transactional Email](/knowledge-base/what-sending-feature-to-use#what-is-a-transactional-email)
2. number of contacts - for [Marketing Email](/knowledge-base/what-sending-feature-to-use#what-is-a-marketing-email)
3. sending rate

These limits help improve your deliverability and likelihood of reaching your recipient's inbox.

<Info>
  Both **sent emails** and **received emails** (inbound) count towards your
  account's email quota. Each received email counts as 1 email against your
  daily and monthly limits, just like sent emails.
</Info>

## Free Account Quotas and Limits

Free accounts have the following:

* Transactional emails: daily email quota of 100 emails/day and 3,000 emails/month. This quota includes both sent and received emails. Multiple `To`, `CC`, or `BCC` recipients in sent emails count as separate emails towards this quota.

* Marketing emails: unlimited emails to up to 1,000 contacts per month.

## Paid Plan Quota

* Transactional Pro, Scale and Enterprise plans have no daily quota limits, though the plan tier will dictate the monthly email quota. Both sent and received emails count towards this monthly quota. To see your current month usage, view the [**Usage page**](https://resend.com/settings/usage). Multiple `To`, `CC`, or `BCC` recipients in sent emails count as separate emails towards the monthly quota.
* Marketing Pro, Enterprise plans have unlimited emails, though the plan tier will dictate the monthly contacts.

## Rate Limits

All accounts start with a rate limit of 2 requests per second. The [rate limits](/api-reference/introduction#rate-limit) follow the [IETF standard](https://datatracker.ietf.org/doc/html/draft-ietf-httpapi-ratelimit-headers) for stating the rate limit in the response header. If you have specific requirements, [contact support](https://resend.com/help) to request a rate increase.

## Bounce Rate

All accounts must maintain a bounce rate of under **4%**. The [**Metrics page**](https://resend.com/metrics) within an account and/or [webhooks](https://resend.com/docs/webhooks/event-types#email-bounced) allow you to monitor your account bounce rates.

Maintaining a bounce rate above 4% may result in a temporary pause in sending until the bounce rate is reduced.

Tips to keep a bounce rate low:

* Remove inactive user email addresses from email lists.
* Only send to recipients who have given consent to receive email.
* When testing, avoid sending to fake email addresses. Use Resend's [test email addresses](/dashboard/emails/send-test-emails) instead.
* If you are using open/click tracking, periodically remove recipients who are not engaging with your emails from your email lists.

## Spam Rate

All accounts must have a spam rate of under **0.08%**. The [**Metrics page**](https://resend.com/metrics) within an account and/or [webhooks](https://resend.com/docs/webhooks/event-types#email-complained) allow you to monitor your account spam rates.

Maintaining a spam rate over 0.08% may result in a temporary pause in sending until the spam rate is reduced.

Tips to keep a spam rate low:

* Give recipients an easy way to opt-out of emails.
* Send relevant and timely emails.
* Only send to recipients who have given consent to receive email.


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

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

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

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

<YouTube />

## 1. Call the Resend integration in Anything

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

<img alt="adding the Resend integration to a Anything chat" />

## 2. Add your Resend API key

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

Click the <Icon icon="plus" /> **Add new secret** button.

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

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

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

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

To send emails to other email addresses:

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

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


# Audience Hygiene: How to keep your Audiences in good shape?
Source: https://resend.com/docs/knowledge-base/audience-hygiene

Learn strategies for maintaining good audience hygiene and maximizing email deliverability.

Audience hygiene (*also known as list hygiene*) refers to the practice of keeping your email list clean, valid, and engaged.

Maintaining proper audience hygiene is crucial for ensuring that your emails reach their intended recipients, maximizing your deliverability, and improving your sender reputation.

By removing invalid, outdated, or disengaged contacts, you can improve the effectiveness of your email campaigns and avoid issues like high bounce rates, low engagement, and even being marked as spam.

***

# How to ensure emails are valid?

To keep your list healthy, it's essential to ensure that the email addresses you collect are valid, accurate, and belong to recipients who are truly interested in hearing from you. Here are a few strategies to help you achieve this:

### Prevent undesired or bot signups with CAPTCHA

Bots can easily sign up for your emails, inflating your list with fake or low-quality contacts. To prevent this, implement CAPTCHA systems during your sign-up process. CAPTCHA challenges help ensure that sign-ups are coming from human users and not automated scripts.

Some popular CAPTCHA services include:

* **[Google reCAPTCHA](https://developers.google.com/recaptcha)**: One of the most widely used CAPTCHA services, offering both simple and advanced protection options.
* **[hCaptcha](https://www.hcaptcha.com/)**: An alternative to Google reCAPTCHA, providing similar protection but with a different user experience.
* **[Friendly Captcha](https://friendlycaptcha.com/)**: A privacy-focused CAPTCHA solution that doesn’t require users to click on anything, reducing friction in the sign-up process.

Using these tools will help reduce bot sign-ups and ensure your email list consists of real users.

### Ensure the recipient is consenting with Double Opt-In

Double opt-in is the process of confirming a user's subscription after they’ve signed up for your emails.

When a user submits their email address, you send them a confirmation email with a link they must click to complete the subscription process.

This step ensures that the person who entered the email address is the one who actually wants to receive your communications.

This is important to ensure:

* **Compliance with local regulations**: Double opt-in helps ensure that you comply with email marketing regulations such as the **CAN-SPAM Act** (U.S.) and **CASL** (Canada). Both of these laws require clear consent from subscribers before you can send them marketing emails.
* **Improved deliverability**: Double opt-in helps you maintain a clean list of genuinely interested users. This reduces bounce rates and prevents spam complaints, which in turn helps maintain your sender reputation with ISPs and inbox providers.
* **Verification of accuracy**: Double opt-in ensures the email addresses you collect are valid, accurate, and up to date, reducing the risk of sending to invalid addresses and impacting your deliverability.

### Use a third-party service to verify an address' deliverability

While you can verify that an email address follows the correct syntax (e.g., [user@example.com](mailto:user@example.com)) (also known as RFC 5322), you also need to ensure that the address is deliverable—that is, it’s an active inbox that can receive emails.

Third-party email verification services can help you identify whether an email address is valid, reachable, or likely to result in a bounce.

This reduces the risk of sending to addresses that won’t receive your emails and improves your overall deliverability.

Some email verification services include:

* **[Emailable](https://emailable.com/partners/resend)**
* **ZeroBounce**
* **Kickbox**

By using these services, you can clean up your existing email lists or prevent undeliverable emails to be added to them. This helps prevent unnecessary deliverability issues.

***

# How to proactively remove emails from your Segments

Over time, certain recipients may become disengaged with your content. It's important to manage your segments by removing inactive or unengaged users.

Regularly filtering your segments ensures that you're sending to only those who are actively interested, which in turn boosts engagement and deliverability.

A healthy email list is one that is continuously nurtured with relevant and timely content. Instead of sporadic communication, maintain consistent engagement with your audience to keep them interested.

### Filter on engagement

To keep your email list in top shape, focus on sending to engaged users. Major inbox providers like Gmail and Microsoft expect you to send emails to recipients who have recently opened or clicked on your emails.

As a best practice, you should limit non-transactional email sends to recipients who have opened or clicked an email in the past 6 months.

<Info>
  The exact timeframe may vary depending on your industry, sending frequency,
  and audience behavior, but 6 months is a generally accepted standard.
</Info>

Regularly cleaning your list of disengaged recipients helps maintain a positive sender reputation and boosts your chances of landing in the inbox instead of the spam folder.

### Automatically remove bounced recipients

Using our [Webhooks](/webhooks/introduction), you can be notified when a delivery bounces or gets marked as spam by the recipient.

This is an opportunity to proactively unsubscribe the recipient and prevent further sending. Indeed, while Resend will automatically suppress further deliveries to that email address, we don't automatically unsubscribe it.

### Sunset unengaged recipients

If certain recipients have not engaged with your emails over an extended period (e.g., 6+ months), consider removing them from your Marketing sends.

Continuing to send to these unengaged users can harm your deliverability by increasing bounce rates and decreasing your open rates.

To re-engage these users, you may want to send a re-engagement campaign or offer an incentive for them to stay on your list. If they don't respond, it's often best to remove them to keep your list healthy and avoid wasting resources on inactive contacts.

***

By maintaining strong audience hygiene practices—including validating email addresses, ensuring consent, verifying deliverability, and removing unengaged recipients—you'll improve your email deliverability and foster better relationships with your subscribers.

This will help you achieve better engagement rates and a healthier sender reputation with inbox providers.


# Send emails with Base44 and Resend
Source: https://resend.com/docs/knowledge-base/base44-integration

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

[Base44](https://base44.com/) is a platform for building apps with AI. You can add Resend in a Base44 project by asking the chat to add email sending with Resend.

<Info>
  This integration requires backend functions, a feature available only on
  Builder tier and above. Learn more about [Base44
  pricing](https://base44.com/pricing).
</Info>

## 1. Add the Resend integration in Base44

**If starting a new app:**

1. Click **Integration** in the top nav.
2. Search for **Resend**, select it, and choose **Use This Integration**.

<img alt="Resend Integration page" />

**If adding Resend to an existing app:**

1. Enable backend functions.
2. Ask the chat: "Add the Resend email integration to my app. Prompt me to provide the API key and send a welcome email to new users."

<Note>
  See the [Base44
  documenation](https://docs.base44.com/Integrations/Resend-integration) for
  more information.
</Note>

## 2. Add your Resend API key

However you add Resend to your project, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

Copy the API key and paste it into the **RESEND\_API\_KEY** field in Base44.

<img alt="Adding your Resend API key to Base44" />

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

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

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](https://resend.com/domains).
2. Add the custom domain to the `from` field in the `resend` function in the Base44 backend function (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/dashboard/domains/introduction).


# Send emails with Bolt.new and Resend
Source: https://resend.com/docs/knowledge-base/bolt-new-integration

Learn how to add the Resend integration to your Bolt.new project.

[Bolt.new](https://bolt.new) is a platform for building full-stack web and mobile apps via chat. You can add Resend in a Bolt.new project by asking the chat to add email sending with Resend.

<img alt="adding the Resend integration to a Bolt.new chat" />

## 1. Add your Resend API key

To use Resend with Bolt.new, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

<Note>
  To safely store your Resend API key, use a `.env` file. You may need to
  include this instruction in your prompt to bolt.new. Learn more about
  [handling API keys](/knowledge-base/how-to-handle-api-keys).
</Note>

## 2. Add a custom domain to your Resend account

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

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](https://resend.com/domains).
2. Add the custom domain to the `from` field in the `resend` function in Bolt.new (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/dashboard/domains/introduction).


# Cloudflare
Source: https://resend.com/docs/knowledge-base/cloudflare

Verify your domain on Cloudflare with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Automatic Setup (Recommended)

The fastest way to verify your domain on Cloudflare is using the **Sign in to Cloudflare** button on Resend. This uses Domain Connect to automatically configure your DNS records.

1. Go to your [Domains page](https://resend.com/domains) in Resend.
2. (Optional) If you want to receive emails, select `Manual setup` and toggle the "Receiving" switch on the domain details page. ([Learn more below](#receiving-emails))
3. Click **Sign in to Cloudflare** button.
4. Authorize Resend to access your Cloudflare DNS settings.
5. The DNS records will be added automatically.

<video aria-label="Cloudflare Domain Connect Setup" />

That's it. Your domain will be verified within a few minutes.

## Manual Setup

If you prefer to add DNS records manually, follow these steps.

### Log in to Cloudflare

Log in to your [Cloudflare account](https://cloudflare.com) and go to the DNS Records of your domain.

<img alt="Domain Details" />

### Add MX SPF Record

Click "Add Record" on Cloudflare:

1. Set the Type to `MX`.
2. Type `send` for the `Name` of the record.
3. Copy the MX Value from Resend into the `Mail Server` field.
4. Use the default `Auto` for `TTL`.
5. Add `10` for the `Priority`.
6. Select `Save`.

<img alt="Domain Details" />

<br />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Cloudflare:

| Cloudflare  | Resend   | Example Value                           |
| ----------- | -------- | --------------------------------------- |
| Type        | Type     | `MX`                                    |
| Name        | Name     | `send`                                  |
| Mail Server | Value    | `feedback-smtp.us-east-1.amazonses.com` |
| Priority    | Priority | `10`                                    |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<Info>
  Do not use the same priority for multiple records. If Priority `10` is already
  in use, try a higher value `20` or `30`.
</Info>

### Add TXT SPF Record

Click "Add Record" on Cloudflare:

1. Set the Type to `TXT`.
2. Type `send` for the `Name` of the record.
3. Copy the TXT Value Resend into `Content` field.
4. Use the default `Auto` for `TTL`.
5. Select `Save`.

<img alt="Domain Details" />

<br />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Cloudflare:

| Cloudflare | Resend  | Example Value                         |
| ---------- | ------- | ------------------------------------- |
| Type       | Type    | `TXT`                                 |
| Name       | Name    | `send`                                |
| Content    | Content | `"v=spf1 include:amazonses.com ~all"` |
| TTL        | -       | `Auto`                                |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

### Add TXT DKIM Records

Click "Add Record" on Cloudflare:

1. Set the Type to `TXT`.
2. Type `resend._domainkey` for the `Name` of the record.
3. Copy the TXT Value Resend into `Content` field.
4. Use the default `Auto` for `TTL`.
5. Select `Save`.

<img alt="Domain Details" />

<br />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Cloudflare:

| Cloudflare   | Resend | Example Value                |
| ------------ | ------ | ---------------------------- |
| Type         | Type   | `TXT`                        |
| Name         | Name   | `resend._domainkey`          |
| Target       | Value  | `p=example_demain_key_value` |
| Proxy Status | -      | `DNS Only (disabled)`        |
| TTL          | -      | `Auto`                       |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

### Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

Click “Add Record” on Cloudflare:

1. Set the Type to `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
3. Copy the MX Value from Resend into the `Mail Server` field.
4. Use the default `Auto` for `TTL`.
5. Add `10` for the `Priority`.
6. Select `Save`.

Below is a mapping of the record fields from Resend to Cloudflare:

| Cloudflare  | Resend   | Example Value                          |
| ----------- | -------- | -------------------------------------- |
| Type        | Type     | `MX`                                   |
| Name        | Name     | `inbound`                              |
| Mail Server | Content  | `inbound-smtp.us-east-1.amazonaws.com` |
| Priority    | Priority | `10`                                   |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

### Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take up to 72 hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Cloudflare returns 'Code: 1004' when adding CNAME Records.">
    Confirm your proxy settings are set to `DNS Only` on the record you are adding.
  </Accordion>

  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Cloudflare to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Does Resend require production approval?
Source: https://resend.com/docs/knowledge-base/does-resend-require-production-approval

Learn about production access and account limitations on Resend.

No, Resend does **not** require production approval. All accounts, including free accounts, have immediate production access from the moment you sign up.

## Free accounts have production access

Free accounts on Resend have full production access immediately. There is no sandbox mode, no approval process, and no waiting period. You can start sending transactional emails to your customers right away.

<Info>
  Resend does not limit free accounts or require authorization to send
  production emails. All accounts have the same production capabilities from day
  one.
</Info>

## Common misconceptions

Some users may think they need production approval if:

* **DNS records aren't generated yet**: If you've added a domain but haven't completed DNS verification, the domain will show as "Pending" until you add the required DNS records. This is not related to account approval—it's simply waiting for domain verification. Once you add and verify your DNS records, you can send from that domain.

* **Coming from other email services**: Some email service providers do require production approval or have sandbox modes. Resend does not have these restrictions.

## Getting started

To start sending emails with Resend:

1. [Sign up for a Resend account](https://resend.com/signup)
2. [Add and verify your domain](https://resend.com/domains)
3. [Create an API key](https://resend.com/api-keys)
4. Start sending emails immediately

If you're having trouble with domain verification or DNS records, see our [domain verification troubleshooting guide](/knowledge-base/what-if-my-domain-is-not-verifying) or check our [DNS setup guides](/knowledge-base/introduction) for your specific DNS provider.


# How to set up E2E testing with Playwright
Source: https://resend.com/docs/knowledge-base/end-to-end-testing-with-playwright

End to end testing ensures your entire app flow is fully functioning.

Below is a basic guide on setting up E2E testing with NextJS, Resend, and Playwright.

Prefer watching a video? Check out our video walkthrough below.

<YouTube />

## 1. Create an endpoint.

For simplicity, we'll create a GET endpoint that sends an email to the testing account, `delivered@resend.dev` on fetch.

```ts app/api/send/route.ts theme={null}
import { Resend } from 'resend';
const resend = new Resend(process.env.RESEND_API_KEY);

export async function GET() {
  try {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello world',
      html: '<h1>Hello world</h1>',
    });

    if (error) {
      return Response.json({ error }, { status: 500 });
    }

    return Response.json({ data });
  } catch (error) {
    return Response.json({ error }, { status: 500 });
  }
}
```

## 2. Write the test spec file

Create a test spec file at `e2e/app.spec.ts`. You can test in two ways:

### Option 1: Call the Resend API

Calling the Resend API tests the entire API flow, including Resend's API responses, but counts towards your account's sending quota.

```ts e2e/app.spec.ts theme={null}
import { test, expect } from '@playwright/test';

test('does not mock the response and calls the Resend API', async ({
  page,
}) => {
  // Go to the page
  await page.goto('http://localhost:3000/api/send');

  // Assert that the response is visible
  await expect(page.getByText('id')).toBeVisible();
});
```

### Option 2: Mock a response

Mocking the response lets you test *your* app's flow without calling the Resend API and impacting your account's sending quota.

```ts e2e/app.spec.ts theme={null}
import { test, expect } from '@playwright/test';

test("mocks the response and doesn't call the Resend API", async ({ page }) => {
  // Sample response from Resend
  const body = JSON.stringify({
    data: {
      id: '621f3ecf-f4d2-453a-9f82-21332409b4d2',
    },
  });

  // Mock the api call before navigating
  await page.route('*/**/api/send', async (route) => {
    await route.fulfill({
      body,
      contentType: 'application/json',
      status: 200,
    });
  });
});
```

<Note>
  However you test, it's important to test using a test email address (e.g.,
  [delivered@resend.dev](mailto:delivered@resend.dev)) so your tests don't impact your deliverability. Resend's
  [test accounts](/dashboard/emails/send-test-emails) run through the entire API
  flow without harming your reputation.
</Note>

## 3. Create a Playwright config file

Write your config file, paying special attention to a few properties:

* `testDir`: the directory containing your test files
* `outputDir`: the directory to store test results
* `webServer`: provide instructions for Playwright to run your app before starting the tests
* `projects`: an array of the browsers you want to test

```ts playwright.config.ts theme={null}
import { defineConfig, devices } from '@playwright/test';
import path from 'path';

const baseURL = 'http://localhost:3000';

export default defineConfig({
  timeout: 30 * 1000,
  testDir: path.join(__dirname, 'e2e'),
  retries: 2,
  outputDir: 'test-results/',
  webServer: {
    command: 'npm run dev',
    url: baseURL,
    timeout: 120 * 1000,
    reuseExistingServer: !process.env.CI,
  },

  use: {
    baseURL,
    // Retry a test if its failing with enabled tracing. This allows you to analyze the DOM, console logs, network traffic etc.
    trace: 'retry-with-trace',
  },

  projects: [
    // Test against desktop browsers.
    {
      name: 'Desktop Chrome',
      use: {
        ...devices['Desktop Chrome'],
      },
    },
    {
      name: 'Desktop Firefox',
      use: {
        ...devices['Desktop Firefox'],
      },
    },
    {
      name: 'Desktop Safari',
      use: {
        ...devices['Desktop Safari'],
      },
    },
    // Test against mobile viewports.
    {
      name: 'Mobile Chrome',
      use: {
        ...devices['Pixel 5'],
      },
    },
    {
      name: 'Mobile Safari',
      use: devices['iPhone 12'],
    },
  ],
});
```

[See the Playwright docs](https://playwright.dev/docs/intro) for more help.

## 4. Run the test

You can run the test by installing Playwright and running the tests.

```bash theme={null}
npx playwright install
npx playwright test
```

Playwright will run the tests in the browsers of your choice and show you the results.

<Card title="Example repo" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-nextjs-playwright-example">
  See the full source code.
</Card>


# Forward emails with Resend Inbound
Source: https://resend.com/docs/knowledge-base/forward-emails-with-resend-inbound

Learn how to forward receiving emails to another email address with Resend Inbound.

Inbound enables you to receive emails with Resend.

This guide demonstrates how to forward received emails using [NextJS](https://nextjs.org/), although you can use any framework you prefer.

<Steps>
  <Step title="Verify a domain with Inbound">
    [Verify a domain](https://resend.com/domains) and enable receiving emails for that domain. We strongly recommend verifying a subdomain (`subdomain.example.com`) instead of the root domain (`example.com`).

    <img alt="Verify a domain with Inbound" />

    Add the records in your DNS provider and wait for verification to finish in Resend. Learn more about [adding Domains in Resend](/dashboard/domains/introduction).

    <Warning>
      When you enable Inbound on a domain, Resend receives *all emails* sent to that
      specific domain depending on the priority of the MX record. For this reason,
      we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
      of the root domain (`example.com`). Learn more about [avoiding conflicts with
      your existing MX
      records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
    </Warning>
  </Step>

  <Step title="Create a POST route">
    Resend can send a webhook to your application's endpoint every time you receive an email.

    Add a new POST route to your application's endpoint.

    ```ts app/api/inbound-webhook/route.ts theme={null}
    import type { NextRequest } from 'next/server';
    import { NextResponse } from 'next/server';

    export const POST = async (request: NextRequest) => {
      try {
        const payload = await request.text();

        return NextResponse.json(payload);
      } catch (error) {
        console.error(error);
        return new NextResponse(`Error: ${error}`, { status: 500 });
      }
    };
    ```
  </Step>

  <Step title="Create a webhook in Resend">
    Go to the [Webhooks page](https://resend.com/webhooks) and click **Add Webhook**.

    1. Add your publicly accessible HTTPS URL.
    2. Select all events you want to observe (e.g., `email.received`).
    3. Click **Add**.

    <img alt="Create a webhook in Resend" />

    <Tip>
      For development, you can create a tunnel to your localhost server using a tool like
      [ngrok](https://ngrok.com/download) or [VS Code Port Forwarding](https://code.visualstudio.com/docs/debugtest/port-forwarding). These tools serve your local dev environment at a public URL you can use to test your local webhook endpoint.

      Example: `https://example123.ngrok.io/api/webhook`
    </Tip>
  </Step>

  <Step title="Add Resend to your project">
    Add the Resend Node.js SDK to your project using your preferred package manager.

    <CodeGroup>
      ```bash npm theme={null}
      npm install resend
      ```

      ```bash yarn theme={null}
      yarn add resend
      ```

      ```bash pnpm theme={null}
      pnpm add resend
      ```

      ```bash bun theme={null}
      bun add resend
      ```
    </CodeGroup>

    Create an [API key with "Full access" permission](/dashboard/api-keys/introduction) in Resend and add it to your project's .env file.

    ```env .env theme={null}
    RESEND_API_KEY=re_xxxxxxxxx
    ```
  </Step>

  <Step title="Verify the webhook request">
    Webhook signing secrets are used to validate the payload data sent to your application from Resend.

    Update your POST route to verify the webhook request using the webhook secret. First, copy the webhook secret from the webhook details page.

    <img alt="Webhook Secret" />

    Then, add it to your project's .env file.

    ```env .env theme={null}
    RESEND_WEBHOOK_SECRET=whsec_xxxxxxxxxx
    ```

    Update the POST route to verify the webhook request using the webhook secret.

    <Tip>
      Make sure that you’re using the raw request body when verifying webhooks. The cryptographic signature is sensitive to even the slightest change. Some frameworks parse the request as JSON and then stringify it, and this will also break the signature verification.
    </Tip>

    ```ts app/api/inbound-webhook/route.ts {3, 5, 12-32} theme={null}
    import type { NextRequest } from 'next/server';
    import { NextResponse } from 'next/server';
    import { Resend } from 'resend';

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

    export async function POST(req: NextRequest) {
      try {
        // we need raw request text to verify the webhook
        const payload = await req.text();

        const id = req.headers.get('svix-id');
        const timestamp = req.headers.get('svix-timestamp');
        const signature = req.headers.get('svix-signature');

        if (!id || !timestamp || !signature) {
          return new NextResponse('Missing headers', { status: 400 });
        }

        // Throws an error if the webhook is invalid
        // Otherwise, returns the parsed payload object
        const result = resend.webhooks.verify({
          payload,
          headers: {
            id,
            timestamp,
            signature,
          },
          webhookSecret: process.env.RESEND_WEBHOOK_SECRET!,
        });

        return NextResponse.json(result);
      } catch (error) {
        console.error(error);
        return new NextResponse(`Error: ${error}`, { status: 500 });
      }
    }
    ```
  </Step>

  <Step title="Process incoming emails">
    Once you verify the webhook, it returns the webhook payload as a JSON object. You can use this payload to forward the email to another email address. Note the following steps:

    1. Add a guard clause to ensure the event type is `email.received`.
    2. Get the incoming email's content
    3. Download and encode any attachments
    4. Forward the email (remember to update the `from` and `to` addresses below)

    <Info>
      You must call the [received emails
      API](/api-reference/emails/retrieve-received-email) to retrieve the email
      content and the [attachments
      API](/api-reference/emails/list-received-email-attachments) to retrieve the
      attachments. This design choice supports large payloads in serverless
      environments that have limited request body sizes.
    </Info>

    ```ts app/api/inbound-webhook/route.ts {29, 34, 42, 67} theme={null}
    import type { NextRequest } from 'next/server';
    import { NextResponse } from 'next/server';
    import { Resend, type ListAttachmentsResponseSuccess } from 'resend';

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

    export async function POST(req: NextRequest) {
      try {
        const payload = await req.text();

        const id = req.headers.get('svix-id');
        const timestamp = req.headers.get('svix-timestamp');
        const signature = req.headers.get('svix-signature');

        if (!id || !timestamp || !signature) {
          return new NextResponse('Missing headers', { status: 400 });
        }

        const result = resend.webhooks.verify({
          payload,
          headers: {
            id,
            timestamp,
            signature,
          },
          webhookSecret: process.env.RESEND_WEBHOOK_SECRET!,
        });

        // 1. Add a guard clause to ensure the event type is `email.received`.
        if (result.type !== 'email.received') {
          return NextResponse.json({ message: 'Invalid event' }, { status: 200 });
        }

        // 2. Get the incoming email's content
        const { data: email, error: emailError } =
          await resend.emails.receiving.get(result.data.email_id);

        if (emailError) {
          throw new Error(`Failed to fetch email: ${emailError.message}`);
        }

        // 3. Download and encode any attachments
        const { data: attachmentsData, error: attachmentsError } =
          await resend.emails.receiving.attachments.list({
            emailId: result.data.email_id,
          });

        if (attachmentsError) {
          throw new Error(
            `Failed to fetch attachments: ${attachmentsError.message}`,
          );
        }

        const attachments =
          attachmentsData?.data as ListAttachmentsResponseSuccess['data'] &
            { content: string }[];

        if (attachments && attachments.length > 0) {
          // download the attachments and encode them in base64
          for (const attachment of attachments) {
            const response = await fetch(attachment.download_url);
            const buffer = Buffer.from(await response.arrayBuffer());
            attachment.content = buffer.toString('base64');
          }
        }

        // 4. Forward the email
        const { data, error: sendError } = await resend.emails.send({
          from: 'onboarding@resend.dev', // replace with an email address from your verified domain
          to: ['delivered@resend.dev'], // replace with the email address you want to forward the email to
          subject: result.data.subject,
          html: email.html,
          text: email.text,
          attachments,
        });

        if (sendError) {
          throw new Error(`Failed to forward email: ${sendError.message}`);
        }

        return NextResponse.json({ message: 'Email forwarded successfully', data });
      } catch (error) {
        console.error(error);
        return new NextResponse(`Error: ${error}`, { status: 500 });
      }
    }
    ```
  </Step>

  <Step title="Test the endpoint">
    You can test the endpoint by sending an email to the domain you verified.

    For example, if you verified `marketing.example.com`, send an email to `test@marketing.example.com`.

    * Try a simple HTML email with a subject and a body.
    * Try an email with an attachment or multiple attachments.

    You can view the received email in the [Emails page](https://resend.com/emails/receiving) and see the webhook payload in the [Webhooks page](https://resend.com/webhooks).
  </Step>

  <Step title="Go to Production">
    Once you've tested the endpoint:

    1. Publish your application to your production environment.
    2. Add your production POST endpoint as a new webhook in Resend.
  </Step>
</Steps>


# Gandi
Source: https://resend.com/docs/knowledge-base/gandi

Verify your domain on Gandi with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to Gandi

Log in to your [Gandi account](https://admin.gandi.net/domain/):

1. Choose your Domain from the `Domain` list.
2. Select the `DNS Records` tab to get to the page to manage DNS records.

<img alt="Domain Details" />

## Add MX SPF Record

Select “Add record” on Gandi to copy and paste the values MX from Resend.

1. On the `Type` page, choose `MX`.
2. Use the default TTL of `10800`.
3. Type `send` for the `Name` of the record.
4. Use the default `Priority` of `10`.
5. Copy the MX Value from Resend into the `Hostname` field.
6. Select `Create`.

<Info>
  Gandi requires your MX record to have a trailing period when adding. Resend
  will include the trailing period when copying. Removing the period will cause
  the verification to fail.
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Gandi:

| Gandi    | Resend   | Example Value                            |
| -------- | -------- | ---------------------------------------- |
| Type     | Type     | `MX Record`                              |
| Name     | Name     | `send`                                   |
| Hostname | Value    | `feedback-smtp.us-east-1.amazonses.com.` |
| TTL      | -        | `10800`                                  |
| Priority | Priority | `10`                                     |

<Info>
  Do not use the same priority for multiple records. If Priority `10` is already
  in use on another record, try a higher value `20` or `30`.
</Info>

## Add TXT SPF Record

In the same section, select “Add record” again.

1. On the `Type` page, choose `TXT`.
2. Use the default TTL of `10800`.
3. Type `send` for the `Name` of the record.
4. Copy the TXT Value Resend into the `Text value` field.
5. Select `Create`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Gandi:

| Gandi      | Resend | Example Value                         |
| ---------- | ------ | ------------------------------------- |
| Type       | Type   | `TXT Record`                          |
| Name       | Name   | `send`                                |
| Text value | Value  | `"v=spf1 include:amazonses.com ~all"` |
| TTL        | -      | `10800`                               |

## Add TXT DKIM Records

In the same section, select “Add record” again.

1. On the `Type` page, choose `TXT`.
2. Use the default TTL of `10800`.
3. Type `resend._domainkey` for the `Host name` of the record.
4. Copy the record value from Resend into the `TXT value` field.
5. Select `Create`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Gandi:

| Gandi      | Resend | Example Value                |
| ---------- | ------ | ---------------------------- |
| Type       | Type   | `TXT Record`                 |
| Name       | Name   | `send`                       |
| Text value | Value  | `p=example_demain_key_value` |
| TTL        | -      | `1 hour`                     |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

Select “Add record” on Gandi:

1. On the `Type` page, choose `MX`.
2. Use the default TTL of `10800`.
3. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
4. Use the default `Priority` of `10`.
5. Copy the MX Value from Resend into the `Hostname` field.
6. Select `Create`.

Below is a mapping of the record fields from Resend to Gandi:

| Gandi    | Resend   | Example Value                           |
| -------- | -------- | --------------------------------------- |
| Type     | Type     | `MX Record`                             |
| Name     | Name     | `inbound`                               |
| Hostname | Content  | `inbound-smtp.us-east-1.amazonaws.com.` |
| TTL      | -        | `10800`                                 |
| Priority | Priority | `10`                                    |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Gandi to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Get Started with Resend and Supabase
Source: https://resend.com/docs/knowledge-base/getting-started-with-resend-and-supabase

A quick jumpstart to using Resend with Supabase.

In this guide, we'll help you get started with Resend by:

* [Setting up Resend](#set-up-resend)
* [Send Auth Emails with Resend](#send-auth-emails-with-resend)
* [Send Emails with Supabase Edge Functions](#send-emails-with-supabase-edge-functions)

## Set up Resend

In order to send emails with your Supabase project, you'll need to first verify it in Resend.

Go to [the Domains page](https://resend.com/domains) and click on **Add Domain**.

1. Add your domain name (we recommend [using a subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain) like `updates.yourdomain.com`).
2. Add the DNS records to your DNS provider ([learn more about these records](/dashboard/domains/introduction)).
   <img alt="Resend Domains page" />
3. Click on **I've added the records** to begin the verification process.
4. Wait for the verification to complete (usually takes 5–10 minutes)

<Info>
  Resend requires you own your domain (i.e., not a shared or public domain).
  Adding DNS records gives Resend the authority to send emails on your behalf
  and signals to the inbox providers that you're a legitimate sender.
</Info>

## Send Auth Emails with Resend

If you want to use Resend to send your Supabase Auth Emails, you have three options:

1. [Using the Resend Integration](#1-using-the-resend-integration): simplest, but less customizable email templates.
2. [Custom Auth Functions](#2-custom-auth-functions): more customizable email templates, but requires more setup.
3. [Self-hosted with Custom SMTP](#3-self-hosted-with-custom-smtp): only for those self-hosting Supabase.

### 1. Using the Resend Integration

Resend includes a pre-built integration with Supabase. Connecting Resend as your email provider will allow you to send your Supabase emails (i.e., password resets, email confirmations, etc.) through Resend.

<YouTube />

1. Open the [Resend Integrations settings](https://resend.com/settings/integrations).
2. Click **Connect to Supabase** and login to your Supabase account if prompted.
   <img alt="Resend Integrations settings" />
3. Select a project and click **Select Project**, then select your domain and click **Add API Key**. Resend will create an API key for you. Add a sender name and click **Configure SMTP Integration**.
   <img alt="Resend Integrations settings" />

Click on **Supabase Dashboard** to confirm the integration.

<img alt="Resend Integrations settings" />

<Info>
  Supabase has a rate limit on the number of emails you can send per hour and
  requires you to [connect a custom email provider for more than 2
  emails/hour](https://supabase.com/docs/guides/auth/rate-limits). Once you set
  Resend as your email provider, you can send additional emails (by default, 25
  emails/hour, although you can change the rate limit in your project's
  [authentication
  settings](https://supabase.com/docs/guides/deployment/going-into-prod#rate-limiting-resource-allocation--abuse-prevention)).
</Info>

### 2. Custom Auth Functions

Benefit of using custom auth functions:

* More control over the email sending process since you control the sending function.
* More control over the email template using React Email or Resend Templates.

Note that this requires enabling [Supabase Auth Hooks](https://supabase.com/docs/guides/auth/auth-hooks).

<YouTube />

<Card title="Supabase Auth Hooks with Resend Templates" icon="arrow-up-right-from-square" href="https://github.com/resend/supabase-auth-hooks-with-resend-templates">
  See the full source code.
</Card>

### 3. Self-hosted with Custom SMTP

If you're self-hosting Supabase, you can use a custom SMTP server to send your emails. [Learn more here](/send-with-smtp).

## Send Emails with Supabase Edge Functions

If you're using Supabase Edge Functions, you can add email sending to your function by using the Resend Node.js SDK. You can use these functions for Auth Emails ([as shown above](#2-custom-auth-functions)) or for other emails (e.g., app notifications, account activity, etc.).

First, make sure you have the latest version of the [Supabase CLI](https://supabase.com/docs/guides/cli#installation) installed.

### 1. Create Supabase function

Create a new function locally:

```bash theme={null}
supabase functions new resend
```

### 2. Edit the handler function

Paste the following code into the `index.ts` file:

```js index.ts theme={null}
import { serve } from "https://deno.land/std@0.168.0/http/server.ts";

const RESEND_API_KEY = 're_xxxxxxxxx';

const handler = async (_request: Request): Promise<Response> => {
    const res = await fetch('https://api.resend.com/emails', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${RESEND_API_KEY}`
        },
        body: JSON.stringify({
            from: 'Acme <onboarding@resend.dev>',
            to: ['delivered@resend.dev'],
            subject: 'hello world',
            html: '<strong>it works!</strong>',
        })
    });

    const data = await res.json();

    return new Response(JSON.stringify(data), {
        status: 200,
        headers: {
            'Content-Type': 'application/json',
        },
    });
};

serve(handler);
```

### 3. Deploy and send email

Run function locally:

```bash theme={null}
supabase functions start
supabase functions serve resend --no-verify-jwt
```

Deploy function to Supabase:

```bash theme={null}
supabase functions deploy resend
```

Open the endpoint URL to send an email:

<img alt="Supabase Edge Functions - Deploy Function" />

### 4. Try it yourself

<Card title="Supabase Edge Functions Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-supabase-edge-functions-example">
  See the full source code.
</Card>

## Happy sending!

If you have any questions, please let us know at [support@resend.com](mailto:support@resend.com).


# GoDaddy
Source: https://resend.com/docs/knowledge-base/godaddy

Verify your domain on GoDaddy with Resend.

Prefer watching a video? Check out our video walkthrough below.

<YouTube />

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to GoDaddy

Log in to your [GoDaddy account](https://sso.godaddy.com):

1. Select `DNS` from the left navigation
2. Find your domain in the list and select the domain
3. This will take you to the DNS management page for the domain

<img alt="Domain Details" />

## Add MX SPF Record

Copy and paste the values MX in Resend to GoDaddy.

1. Click `Add New Record` to create a new record
2. Set the Type to `MX`.
3. Type `send` for the `Name` of the record.
4. Copy the MX Value from Resend into the `Value` field.
5. Add `10` for the `Priority`.
6. Set the TTL to `600` (or use the default).
7. Click `Save`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to GoDaddy:

| GoDaddy  | Resend   | Example Value                           |
| -------- | -------- | --------------------------------------- |
| Type     | Type     | `MX Record`                             |
| Name     | Name     | `send`                                  |
| Value    | Value    | `feedback-smtp.us-east-1.amazonses.com` |
| TTL      | -        | `600` (or use default)                  |
| Priority | Priority | `10`                                    |

<Info>
  Do not use the same priority for multiple records. If Priority `10` is already
  in use on another record, try a higher value `20` or `30`.
</Info>

## Add TXT SPF Record

In the same section, add another record in GoDaddy.

1. Click `Add New Record` to create a new record
2. Set the Type to `TXT`.
3. Type `send` for the `Name` of the record.
4. Copy the TXT Value from Resend into the `Value` field.
5. Set the TTL to `600` (or use the default).
6. Click `Save`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to GoDaddy:

| GoDaddy | Resend | Example Value                         |
| ------- | ------ | ------------------------------------- |
| Type    | Type   | `TXT Record`                          |
| Name    | Name   | `send`                                |
| Value   | Value  | `"v=spf1 include:amazonses.com ~all"` |
| TTL     | -      | `600` (or use default)                |

## Add TXT DKIM Records

In the same section, add another record in GoDaddy.

1. Click `Add New Record` to create a new record
2. Set the Type to `TXT`.
3. Type `resend._domainkey` for the `Name` of the record.
4. Copy the record value from Resend into the `Value` field.
5. Set the TTL to `600` (or use the default).
6. Click `Save`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to GoDaddy:

| GoDaddy | Resend | Example Value                |
| ------- | ------ | ---------------------------- |
| Type    | Type   | `TXT Record`                 |
| Name    | Name   | `resend._domainkey`          |
| Value   | Value  | `p=example_demain_key_value` |
| TTL     | -      | `600` (or use default)       |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

Click `Add New Record` to create a new record:

1. Set the Type to `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
3. Copy the MX Value from Resend into the `Value` field.
4. Add `10` for the `Priority`.
5. Set the TTL to `600` (or use the default).
6. Click `Save`.

Below is a mapping of the record fields from Resend to GoDaddy:

| GoDaddy  | Resend   | Example Value                          |
| -------- | -------- | -------------------------------------- |
| Type     | Type     | `MX Record`                            |
| Name     | Name     | `inbound`                              |
| Value    | Content  | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL      | -        | `600` (or use default)                 |
| Priority | Priority | `10`                                   |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to GoDaddy to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Hetzner
Source: https://resend.com/docs/knowledge-base/hetzner

Verify your domain on Hetzner with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to Hetzner

Log in to your [Hetzner account](https://dns.hetzner.com):

1. Choose your Domain from the `Your Zones` list.
2. Select the `Records` tab to get to the page to manage DNS records.

<img alt="Domain Details" />

## Add MX SPF Record

In the `Create Record` section on Hetzner copy and paste the values MX from Resend:

1. On the `Type` page, choose `MX`.
2. Type `send` for the `Name` of the record.
3. Select the `Value` field.
4. Use the default `Priority` of `10`.
5. Copy the MX Value from Resend into the `Mail server` field.
6. Select the TTL of `1800`.
7. Select `Add Record`.

<Info>
  Hetzner requires your MX record to have a trailing period when adding. Resend
  will include the trailing period when copying. Removing the period will cause
  the verification to fail.
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Hetzner:

| Hetzner     | Resend   | Example Value                            |
| ----------- | -------- | ---------------------------------------- |
| Type        | Type     | `MX Record`                              |
| Name        | Name     | `send`                                   |
| Mail server | Value    | `feedback-smtp.us-east-1.amazonses.com.` |
| TTL         | TTL      | `1800`                                   |
| Priority    | Priority | `10`                                     |

<Info>
  Do not use the same priority for multiple records. If Priority `10` is already
  in use on another record, try a higher value `20` or `30`.
</Info>

## Add TXT SPF Record

On the same `Create Record` section:

1. On the `Type` page, choose `TXT`.
2. Type `send` for the `Name` of the record.
3. Copy the TXT Value Resend into the `Value` field.
4. Select the TTL of `1800`.
5. Select `Add Record`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Hetzner:

| Hetzner | Resend | Example Value                         |
| ------- | ------ | ------------------------------------- |
| Type    | Type   | `TXT Record`                          |
| Name    | Name   | `send`                                |
| Value   | Value  | `"v=spf1 include:amazonses.com ~all"` |
| TTL     | TTL    | `10800`                               |

## Add TXT DKIM Records

On the same `Create Record` section:

1. On the `Type` page, choose `TXT`.
2. Type `resend._domainkey` for the `Name` of the record.
3. Copy the TXT Value Resend into the `Value` field.
4. Select the TTL of `1800`.
5. Select `Add Record`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Hetzner:

| Hetzner | Resend | Example Value                |
| ------- | ------ | ---------------------------- |
| Type    | Type   | `TXT Record`                 |
| Name    | Name   | `send`                       |
| Value   | Value  | `p=example_demain_key_value` |
| TTL     | TTL    | `1 hour`                     |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

In the `Create Record` section on Hetzner:

1. On the `Type` page, choose `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
3. Select the `Value` field.
4. Use the default `Priority` of `10`.
5. Copy the MX Value from Resend into the `Mail server` field.
6. Select the TTL of `1800`.
7. Select `Add Record`.

Below is a mapping of the record fields from Resend to Hetzner:

| Hetzner     | Resend   | Example Value                           |
| ----------- | -------- | --------------------------------------- |
| Type        | Type     | `MX Record`                             |
| Name        | Name     | `inbound`                               |
| Mail server | Content  | `inbound-smtp.us-east-1.amazonaws.com.` |
| TTL         | TTL      | `1800`                                  |
| Priority    | Priority | `10`                                    |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Hetzner to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Hostinger
Source: https://resend.com/docs/knowledge-base/hostinger

Verify your domain on Hostinger with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to Hostinger

Log in to your [Hostinger account](https://auth.hostinger.com/login):

1. Select the `Domains` tab
2. Choose your Domain from the `Domain portfolio` list.
3. Select the `DNS / Nameservers` to get to the page to manage DNS records.

<img alt="Domain Details" />

## Add MX SPF Record

Copy and paste the values MX in Resend to Hostinger.

1. Set the Type to `MX`.
2. Type `send` for the `Name` of the record.
3. Copy the MX Value from Resend into the `Mail Server` field.
4. Add `10` for the `Priority`.
5. Set the TTL to `3600`.
6. Select `Add Record`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Hostinger:

| Hostinger   | Resend   | Example Value                           |
| ----------- | -------- | --------------------------------------- |
| Type        | Type     | `MX Record`                             |
| Name        | Name     | `send`                                  |
| Mail Server | Value    | `feedback-smtp.us-east-1.amazonses.com` |
| TTL         | -        | `Set to 3660`                           |
| Priority    | Priority | `10`                                    |

<Info>
  Do not use the same priority for multiple records. If Priority `10` is already
  in use on another record, try a higher value `20` or `30`.
</Info>

## Add TXT SPF Record

In the same section, add another record in Hostinger.

1. Set the Type to `TXT`.
2. Type `send` for the `Name` of the record.
3. Copy the TXT Value Resend into the `TXT value` field.
4. Set the TTL to `3600`.
5. Select `Add Record`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Hostinger:

| Hostinger | Resend | Example Value                         |
| --------- | ------ | ------------------------------------- |
| Type      | Type   | `TXT Record`                          |
| Name      | Name   | `send`                                |
| TXT value | Value  | `"v=spf1 include:amazonses.com ~all"` |
| TTL       | -      | `Set to 3600`                         |

## Add TXT DKIM Records

In the same section, add another record in Hostinger.

1. Set the Type to `TXT`.
2. Type `resend._domainkey` for the `Name` of the record.
3. Copy the record value from Resend into the `TXT value` field.
4. Set the TTL to `3600`.
5. Select `Add Record`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Hostinger:

| Hostinger | Resend | Example Value                |
| --------- | ------ | ---------------------------- |
| Type      | Type   | `TXT Record`                 |
| Name      | Name   | `send`                       |
| TXT value | Value  | `p=example_demain_key_value` |
| TTL       | -      | `Set to 3600`                |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

Copy and paste the values MX in Resend to Hostinger:

1. Set the Type to `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
3. Copy the MX Value from Resend into the `Mail Server` field.
4. Add `10` for the `Priority`.
5. Set the TTL to `3600`.
6. Select `Add Record`.

Below is a mapping of the record fields from Resend to Hostinger:

| Hostinger   | Resend   | Example Value                          |
| ----------- | -------- | -------------------------------------- |
| Type        | Type     | `MX Record`                            |
| Name        | Name     | `inbound`                              |
| Mail Server | Content  | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL         | -        | `Set to 3660`                          |
| Priority    | Priority | `10`                                   |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Hostinger to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# How can I delete my Resend account?
Source: https://resend.com/docs/knowledge-base/how-can-i-delete-my-resend-account

How to request your Resend account and data to be deleted.

To delete your Resend account:

1. [Leave the team](/dashboard/settings/team#leave-your-resend-team) associated with your Resend account.
2. Select the **Delete account** button.

Upon confirmation, Resend will delete your account and all account data.

<Warning>
  Please note that this action is not reversible, so please proceed with
  caution.
</Warning>


# How can I delete my Resend team?
Source: https://resend.com/docs/knowledge-base/how-can-i-delete-my-team

How to request your Resend team and team data to be deleted.

To request your Resend team and team data to be deleted:

1. Navigate to your [**Team Settings**](https://resend.com/settings/team).
2. Select the **Delete Team** button.

Upon confirmation, Resend will delete your team and all your team data.

<Note>
  If you are the last member of a team, you can also delete it by selecting
  **Leave Team** instead. The system will automatically delete the team when the
  last member leaves.
</Note>

<Warning>
  Please note that this action is not reversible, so please proceed with
  caution.
</Warning>


# Can I receive emails with Resend?
Source: https://resend.com/docs/knowledge-base/how-can-i-receive-emails-with-resend

Receiving emails is in early access.

We're currently working on inbound email, [sign-up to join our early access waitlist](https://resend.com/inbound). The key components of this feature will include:

* Receive emails using webhooks. Get notified when emails are received.
* Parse content and attachments. Extract and process email data automatically.
* Reply to your users. Respond directly to incoming messages.

While this feature is in early access, you can still [set a Reply To Address](api-reference/emails/send-email) (`reply_to`) on your outbound emails to direct any responses to a different location like an existing inbox, slack channel, etc.

Here are a few current workarounds that could help:

* **Sending to existing inbox**: You could set the `reply_to` as your personal email address. If any recipient replies to your email, it will be sent to the `reply_to` address. This could be a different address on the same domain, or a different domain entirely.
* **Sending to Slack**: You could set the `reply_to` as a [channel email address in Slack](https://slack.com/help/articles/206819278-Send-emails-to-Slack). This will create a new message in slack with the contents of the reply.


# How do I create an email address or sender in Resend?
Source: https://resend.com/docs/knowledge-base/how-do-I-create-an-email-address-or-sender-in-resend

Learn how sending from an email address works on Resend.

Resend does **not** require you to “create an email address”, “set up a sender identity”, or “add a from-address” before sending.

Once a domain is verified in your Resend account, you can send from **any** email address at that domain.

<Info>
  The email address you send from does **not** need to exist in another system.
  However, we recommend using addresses that can receive replies.
</Info>

## Common misconceptions

Some platforms require you to create, register, or pre-approve a sending address.\
Resend does **not**. After verifying your domain, you’re free to send from any address **@yourdomain**, with no extra setup, creation, or configuration of that address.

## Getting started

To start sending emails with Resend:

1. [Sign up for a Resend account](https://resend.com/signup)
2. [Add and verify your domain](https://resend.com/domains)
3. [Create an API key](https://resend.com/api-keys)
4. Start sending emails immediately from any address at the domain you verified

If you're having trouble with domain verification or DNS records, see our [domain verification troubleshooting guide](/knowledge-base/what-if-my-domain-is-not-verifying) or check our [DNS setup guides](/knowledge-base/introduction) for your specific DNS provider.


# How do Dedicated IPs work?
Source: https://resend.com/docs/knowledge-base/how-do-dedicated-ips-work

When are Dedicated IPs helpful, and how can they be requested.

## What is a Dedicated IP?

In email delivery, the sending IP address serves as a key identifier. Inbox Providers like Gmail track the reputation of these IPs based on the quality and quantity of emails sent from them, factoring this information into filtering and inbox placement decisions.

By default, all Resend users utilize our shared IPs, which are a collection of IPs shared across many senders. Optionally, you can purchase a dedicated IP pool so a range of IPs are exclusively assigned to your sending.

Resend goes one step further and exclusively provisions "Managed Dedicated IP Pools". These managed pools handle multiple delicate and time consuming aspects of dedicated IPs:

* **Automatic warmup**: New IPs have no reputation and are therefore under scrutiny by inbox providers. We carefully migrate your sending over from the shared pool to your dedicated pool.
* **Automatic scaling**: IPs can only send at a certain rate based on the specifications of each inbox provider. We scale your pool dynamically based on the inbox provider feedback, without you lifting a finger.
* **Continuous monitoring**: Resend continuously monitors the reputation and performance of your dedicated IPs.
* **Fully dedicated**: You can segregate your emails from sending on shared pools to reduce risk of "noisy neighbors".

<Note>
  Resend only provisions Managed Dedicated IP Pools, but we will refer to them
  as **Dedicated IPs** in this article to be succinct.
</Note>

## When are Dedicated IPs helpful?

Historically, Dedicated IPs were seen as the primary ingredient to great deliverability. This is not true anymore as Inbox Providers have incorporated dozens of other factors like sending history, domain reputation, and sending feedback (bounces and complaints) more predominantly than IP reputation.

Though Dedicated IPs are not a deliverability silver bullet, they maintain a very helpful benefit: **removing risk of noisy neighbors**.

There is power in numbers, and for many senders it can be very helpful to leverage the positive reputation of other senders in an IP pool. For some senders though, they want to maintain their own IP reputation without any chance of being impacted, positively or negatively, by other senders. For them, Dedicated IPs are a helpful solution.

## When are Dedicated IPs not helpful?

Dedicated IPs can be very helpful, but there are some situations where they can actually hinder your ability to reach the inbox. If any of these situations match your use case, Dedicated IPs may hinder more than help:

* **Low email volume**: Sending less than 30k emails a month may not be enough to keep the IPs warm.
* **Inconsistent sending**: Sudden changes in email volume can hurt your IP reputation.
* **Poor email practices**: A Dedicated IP simply exposes your sending behavior even more.
* **New sender**: If you're just starting out and have no sending history.
* **IP Allowlisting**: Resend does not expose the IPs included in your dedicated pool.

## How does IP warmup work?

With Resend's Managed Dedicated IP Pools, the warmup process is handled automatically:

1. **Automatic scaling**: Add or remove IP addresses based on your sending volume.
2. **Gradual increase**: Gradually increase the volume of emails sent through new IPs over time.
3. **Traffic distribution**: During warmup, traffic is distributed across shared and dedicated IPs.
4. **Reputation monitoring**: Continuously monitor the reputation of your dedicated IPs.
5. **Adaptive warmup**: Adapt the warmup process to your sending patterns.

Often IP warmup is a highly manual process and requires great care if you don't want a deliverability degradation in the process. With this automatic warmup process, we handle that for you so you can simply focus on sending.

<Note>
  Because Managed Dedicated IP Pools are dynamically scaled, **we do not expose
  the list of IPs** in your dedicated pool.
</Note>

## Requirements for a Dedicated IP

Before we can provision a Dedicated IP, **we require** that:

* Your domains are in the same region (Dedicated IPs are provisioned per region).
* Your sending volume exceeds 500 emails sent per day.
* You already have an active Transactional Scale or Marketing Pro subscription.
* All domains you want added to the Dedicated IP are already verified on Resend.

## How to request a Dedicated IP

You can request a Dedicated IP by [chatting with support](https://resend.com/help).

**We will request the following information**:

* What types of emails are you sending?
* How many emails are you sending per day and month on average?
* Is your sending consistent every day, or do you send in bursts?
* Which domains do you want included in your Dedicated IP?


# How do I avoid conflicts with my MX records?
Source: https://resend.com/docs/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records

Learn how to avoid conflicts with your existing MX records when setting up a Resend domain.

## What is an MX record?

MX (Mail Exchanger) records specify where incoming mail should be delivered on behalf of a domain. Every MX value has a unique priority (also known as preference) value. The lower the number, the higher the priority.

Resend requires that you setup a MX record on two occasions:

1. **[Enabling your domain to send emails](https://resend.com/docs/dashboard/emails/introduction)**: You need to setup an MX record on `send.yourdomain.com` to establish a return-path for bounce/complaint reports from Inbox Providers. We set this return path in the email headers of every email you send through Resend.

2. **[Enabling your domain to receive emails](https://resend.com/docs/dashboard/receiving/custom-domains)**: You can setup an MX record on your domain to route all received emails to Resend.

## Won't this conflict with my existing Inbox Provider?

Let's look at an example for each occasion Resend requires you to setup a MX record.

Say you're using G Suite for your email. You'll have an MX record that looks something like this:

```
yourdomain.com     MX    10 alt3.aspmx.l.google.com.
```

This records specifies that any incoming mail to `<anything>@yourdomain.com` should be delivered to the google servers.

Now, let's say you want to use Resend to send emails from `@yourdomain.com`. You'll need to add an MX record for `send.yourdomain.com` that looks something like this:

```
send.yourdomain.com     MX    10 feedback-smtp.us-east-1.amazonses.com
```

This **won't** conflict because the MX record is for `send.yourdomain.com`, not `yourdomain.com`. MX records only impact the subdomain they are associated to, so the Resend MX record will not affect your existing records on the root domain.

Now say you want to start receiving emails through Resend.

Because you already have the MX record `yourdomain.com`, you have two options:

1. **\[Recommended] Create a MX record for a subdomain** (e.g. `subdomain.yourdomain.com`). Now emails sent to `<anything>@yourdomain.com` will continue going to G Suite, and emails sent to `<anything>@subdomain.domain.com` will go to Resend.

2. **Create a MX record with the lowest priority** among the other MX record for your domain.
   Since on our example, you already had a MX record for `yourdomain.com` point to G Suite, you would create:

```
yourdomain.com    MX    9  inbound-smtp.us-east-1.amazonaws.com
```

Now this MX record priority has a lower value (higher priority) so it will be prioritized. But keep in mind that:

<Note>
  * This *will* route **all** emails destined to `<anything>@yourdomain.com` to Resend, insted of your previous provider(e.g. G Suite)
  * If two MX records have the same priority value, this does **not** mean it will send to both servers — instead only one server will be chosen, randomly, per email delivery attempt.
</Note>

## Solving common conflicts

<AccordionGroup>
  <Accordion title="Conflicts with existing records">
    If you already have a MX record set for `send.yourdomain.com`, you will need to remove it before adding the Resend MX record.

    If you need to keep the existing record, you can add a subdomain to your domain (e.g. `sub.yourdomain.com`) which will move the Resend MX location to `send.sub.yourdomain.com`.
  </Accordion>

  <Accordion title="Conflicts with existing priority">
    Each MX should have a unique priority value. We suggest using 10 for your MX record on `send.yourdomain.com`, but you can use a lower number (higher priority) if 10 is already in use.

    <Note>
      The lowest possible value (highest priority) is 0. So if you already have a record with this priority, you'll need to remove it in order to create the MX record for Resend.
    </Note>
  </Accordion>
</AccordionGroup>


# How do I avoid Gmail's spam folder?
Source: https://resend.com/docs/knowledge-base/how-do-i-avoid-gmails-spam-folder

Learn how to improve inbox placement in Gmail.

<Note>
  This guide is adapted from Google's article to [Prevent mail from being
  blocked or sent to
  spam](https://support.google.com/mail/answer/81126?hl=en\&vid=1-635789122382665739-3305764358\&sjid=4594872399309427672-NA#thirdparty)
</Note>

## Authenticate Your Email

All communication is built on trust, and email is no different. When you send an email, you want to be sure that the recipient (and Gmail) knows who you are and that you are a legitimate sender. Email authentication is a way to prove that an email is really from you. It also helps to prevent your email from being spoofed or forged.

| Authentication                    | Requires Setup | Purpose                                                      |
| --------------------------------- | -------------- | ------------------------------------------------------------ |
| **SPF**                           | No             | Proves you are allowed to send from this domain              |
| **DKIM**                          | No             | Proves your email originated from you                        |
| [DMARC](/dashboard/domains/dmarc) | Yes            | Proves you own the domain and instructs how to handle spoofs |
| [BIMI](/dashboard/domains/bimi)   | Yes            | Proves you are the brand you say you are                     |

**SPF** and **DKIM** are baseline requirements for all sending which is why both are automatically setup when you verify your domain with Resend. [DMARC](/dashboard/domains/dmarc) and [BIMI](/dashboard/domains/bimi) are both additional authentication methods that can build trust and further improve inbox placement.

**Action Items**

1. [Setup DMARC](/dashboard/domains/dmarc) for your domain
2. [Setup BIMI](/dashboard/domains/bimi) for your domain

## Legitimize Your Domain

Gmail is using many methods to identify who you are as a sender, and one way they do that is by looking at your domain. You should make sure that the domain you send with is the same domain where your website is hosted. If you send from `@example.com` but your website is hosted at `example.net`, Gmail won't be able to use your site to help legitimize you.

You can regularly check if your domain is listed as unsafe with [Google Safe Browsing](https://transparencyreport.google.com/safe-browsing/search?hl=en) to make sure Google isn't classifying your domain as suspicious.

**Action Items**

1. Host your website at the domain that you send from (especially for new domains)
2. Check if your domain is listed as unsafe with [Google Safe Browsing](https://transparencyreport.google.com/safe-browsing/search?hl=en)

## Manage your Mailing List

Gmail monitors your sending across all Gmail inboxes to see if recipients want to receive your emails. This is mainly measured by their engagement with your messages (opens, clicks, replies). If Gmail doesn't see this engagement, they will start to move your inbox placement towards promotional or even spam.

It would seem like adding open and click tracking would be ideal to gather this information, but this has been seen to negatively impact your inbox placement. Instead, focus on sending to recipients who want to receive your emails.

**Prevent sending to recipients who**:

* Didn't ask to be sent to (opt-in)
* Show no signs of engagement with your emails or product
* Requested to be unsubscribed
* Marked your emails as spam (complained)
* Never received your email (bounced)

**Action Items**

1. Make it easy to opt-out to your emails (including the [Unsubscribe Headers](https://resend.com/docs/dashboard/emails/add-unsubscribe-to-transactional-emails))
2. Use [Webhooks](/webhooks/introduction) to remove bounced or complained recipients from your list
3. Use [Gmail's Postmaster Tool](https://support.google.com/mail/answer/9981691?sjid=4594872399309427672-NA\&visit_id=638259770782293948-1913697299\&rd=1) to monitor your spam reports

## Monitor Affiliate Marketers

Affiliate marketing programs offer rewards to companies or individuals that send visitors to your website. However, spammers can take advantage of these programs. If your brand is associated with marketing spam, other messages sent by you might be marked as spam.

We recommend you regularly monitor affiliates, and remove any affiliates that send spam.

**Action Items**

1. Monitor your affiliate marketers for any spam

## Make Content People Want to Read

Trust is not only built with the domain, but also in the message. Sending content that people want to read and that is not misleading will help build trust with Gmail.

A few good rules for content:

* Less is more (keep it simple and to the point)
* Plain text over complex HTML
* Links should be visible and match the sending domain
* No content should be hidden or manipulative

**Action Items**

1. Reduce and simplify your email content
2. Make sure your links are using your sending domain

## Establish Sending Patterns

This is especially true for new domains since Gmail doesn't have any history of trust. Sending a large volume of emails from a new domain will likely result in poor inbox placement. Instead, start small and build up your sending volume over time.

A great way to start is by sending regular person-to-person email with your gmail account. These messages will have high engagement and built trust quickly, which will carry over when you start integrating with a sending service like Resend.

It can also be very helpful to segment your sending by sending address to give Gmail more indication of what type of sending you are doing. This allows Gmail to place your emails in the correct inbox tab (Primary, Promotions, etc.).

Some examples of helpful email addresses:

* **Personal emails** should come from an address with a name like [marissa@domain.com](mailto:marissa@domain.com)
* **Transactional emails** should come from an address like [notifications@domain.com](mailto:notifications@domain.com)
* **Marketing emails** should come from an address like [updates@domain.com](mailto:updates@domain.com).

**Action Items**

1. Send emails from your gmail account before sending transactional
2. Send transactional emails before sending marketing emails
3. Choose dedicated sending addresses for each type of email

## Summary

Email deliverability is overwhelming. One way to simplify it is to think: **what would a phisher do?**

**Then do the opposite!**

Gmail's goal is to only show emails that their users want to see and malicious emails are at the very bottom of the list. Reverse engineer phishing sending habits and consider how you could prove to Gmail at each step that you clearly have no malicious intent.

<Info>Anything we missed? [Let us know](https://resend.com/help).</Info>


# How do I avoid Outlook's spam folder?
Source: https://resend.com/docs/knowledge-base/how-do-i-avoid-outlooks-spam-folder

Learn how to improve inbox placement in Outlook.

<Note>
  This guide is adapted from Microsoft's article to [Improve your spam
  reputation](https://support.microsoft.com/en-us/office/sender-support-in-outlook-com-05875e8d-1950-4d89-a5c3-adc355d0d652).
  For high-volume senders (5,000+ messages per day), see [Microsoft's bulk
  sending requirements for
  2025](https://resend.com/blog/microsoft-bulk-sending-requirements-2025).
</Note>

* **Set up email authentication**. Configure [SPF, DKIM, and DMARC](/dashboard/domains/introduction) for your domain. This is required for bulk senders (5,000+ messages per day) and strongly recommended for all senders.

* **Add your sender name**. Set your `from` like this: `"Name <name.domain.com>"`.

* **Engage with your own email**. Send an email to yourself, open it, and reply to it.

* **Add yourself as a contact**. See how to add contacts in [Outlook.com](https://support.microsoft.com/en-us/office/create-view-and-edit-contacts-and-contact-lists-in-outlook-com-5b909158-036e-4820-92f7-2a27f57b9f01).

* **Ask your recipients to add you in their contacts**. This can be done in [Outlook](https://support.microsoft.com/en-us/office/add-recipients-of-my-email-messages-to-the-safe-senders-list-be1baea0-beab-4a30-b968-9004332336ce) or [outlook.com](https://support.microsoft.com/en-us/office/safe-senders-in-outlook-com-470d4ee6-e3b6-402b-8cd9-a6f00eda7339).

* **Don't blast to a BCC list**. Send separate emails if you are sending to a large number of recipients.

* **Prevent over sending**. Limits are impacted by historical engagements and sending volumes, but you should be hesitant to send too many emails at once. If you think this is an issue, reduce the frequency or volume.

* **Send to engaged recipients**. Don't keep sending if there is no engagement from your recipients. This is especially true if a recipient has requested to unsubscribe or an address is bouncing. Keep spam complaint rates under 0.3%.

* **Include an unsubscribe option**. For bulk emails, include a clearly visible unsubscribe link. Consider implementing [one-click unsubscribe](/dashboard/emails/add-unsubscribe-to-transactional-emails) for the best user experience.

* **Limit use of HTML**. Keep emails as close to plain text as possible.


# How do I ensure sensitive data isn't stored on Resend?
Source: https://resend.com/docs/knowledge-base/how-do-i-ensure-sensitive-data-isnt-stored-on-resend

Information on how we can help you protect your customer's information.

Resend can turn off message content storage for teams with additional compliance requirements. This is available to customers who meet the following criteria:

1. The team has been a Resend Pro or Scale subscriber for at least 1 month.
2. The team is sending from a domain with an active website.
3. The team has sent over 3,000 emails with a \< 5% bounce rate.

This feature requires a \$50/mo add-on. If your account meets these requirements and you would like this turned on, contact our support team for help.


# How do I fix CORS issues?
Source: https://resend.com/docs/knowledge-base/how-do-i-fix-cors-issues

Information on recommended options to avoid CORS errors when sending emails.

## Problem

It's common for people to hit CORS (Cross-Origin Resource Sharing) issues when using the Resend API. This error typically shows as:

```
Access to XMLHttpRequest at 'https://api.resend.com/emails'
from origin 'http://localhost:3000' has been blocked by CORS policy:
Response to preflight request doesn't pass access control check:
No 'Access-Control-Allow-Origin' header is present on the requested resource.
```

## Solution

Usually CORS errors happens when you're sending emails from the **client-side**.

We recommend you to send the emails on the **server-side** to not expose your API keys and avoid CORS issues.


# How do I maximize deliverability for Supabase Auth emails?
Source: https://resend.com/docs/knowledge-base/how-do-i-maximize-deliverability-for-supabase-auth-emails

Everything you should do before you start sending authentication emails with Resend and Supabase.

<Note>
  If you haven't yet, [configure your own Supabase
  integration](https://resend.com/settings/integrations)!
</Note>

Below are **five steps to improve the deliverability of your authentication emails**.

Prefer watching a video? Check out our video walkthrough below.

<YouTube />

## 1. Setup a custom domain on Supabase

By default, Supabase generates a `supabase.co` domain for your project, and uses that domain for the links in your authentication emails (e.g., verify email, reset password).

Once you are ready to go live, though, it is important to setup a custom domain. The key benefit here is to align the domains used in your `from` address and the links in your emails. Especially for something as sensitive as email verification and magic links, **giving confidence to the inbox providers that the origin of the email and the links in the body are the same** can be very impactful.

This changes your links from:

```
https://039357829384.supabase.co/auth/v1/{code}
```

To something like this:

```
https://auth.yourdomain.com/auth/v1/{code}
```

Supabase has a helpful guide for [Setting up a custom domain](https://supabase.com/docs/guides/platform/custom-domains).

## 2. Setup a dedicated subdomain

There are many benefits to using a subdomain vs your root domain for sending, one being that you can isolate the reputation of the subdomain from your root domain.

For authentication emails, using a subdomain is particularly helpful because it is a way to **signal your intention to the inbox provider**. For example, if you use `auth.yourdomain.com` for your authentication emails, you are communicating to the inbox provider that all emails from this subdomain are related to sending authentication emails.

This clarity is essential because it helps the inbox provider understand that this subdomain is not used for sending marketing emails, which are more likely to be marked as spam.

<Note>
  If you don't want a subdomain just for auth, you can also achieve this by
  establishing one subdomain for all your transactional emails (e.g.,
  `notifications.yourdomain.com`).
</Note>

To add a subdomain to Resend, you can [add it as a domain on the dashboard](https://resend.com/domains).

<img alt="Create auth subdomain" />

## 3. Disable link and open tracking

Link and open tracking can be great for marketing emails but not for transactional emails. This kind of **tracking can actually hurt your deliverability**. Open tracking embeds a 1x1 pixel image in the email, and link tracking rewrites the links in the email to point to Resend's servers first. Both types can be seen as suspicious by the inbox provider and hurt your deliverability.

Also, Supabase has noted that link tracking is [known for corrupting verification links](https://supabase.com/docs/guides/platform/going-into-prod), making them unusable for your users.

You can disable link and open tracking by clicking on your domain and disabling at the bottom.

<img alt="Disable link and open tracking" />

## 4. Prepare for link scanners

Some inbox providers or enterprise systems have email scanners that run a `GET` request on all links in the body of the email. This type of scan can be problematic since Supabase Auth links are single-use.

To get around this problem, consider altering the email template to replace the original magic link with a link to a domain you control. The domain can present the user with a "Sign-in" button, which redirects the user to the original magic link URL when clicked.

## 5. Setup DMARC

Like our human relationships, email deliverability is built on trust. The more inboxes can trust your emails, your domain, and your sending, the more likely your emails will be delivered to the inbox. This makes [Email Authentication a critical pillar](https://resend.com/blog/email-authentication-a-developers-guide) in the journey to excellent deliverability.

That is where DMARC comes in. As the industry standard for email authentication, **DMARC is a way to tell the inbox provider that you are who you say you are**. It is a way to signal to the inbox provider that you are a legitimate sender and that your emails should be delivered to the inbox.

Following security best practices like DMARC will show your validity and authenticity.

<img alt="DMARC policy details" />

You can use our [DMARC setup guide to get started](/dashboard/domains/dmarc).


# How do I send with an avatar?
Source: https://resend.com/docs/knowledge-base/how-do-i-send-with-an-avatar

Learn how to show your avatar in the inbox of your recipients.

[Recent studies](https://www.businesswire.com/news/home/20210720005361/en/Red-Sift-and-Entrust-Survey-Showing-a-Logo-Positively-Affects-Consumer-Interaction-With-Emails-Open-Rates-Buying-Behavior-Brand-Recall-and-Confidence) are showing meaningful benefits of displaying your logo in the inbox:

* Increases brand recall by 18%.
* Improves open rate by 21%.
* Boosts purchase likelihood by 34%.
* Reinforces confidence in email by 90%.

<img alt="Email with an avatar" />

## Gmail

Follow these steps to add an avatar to your Gmail inbox:

1. Go to your [Google Account Settings](https://myaccount.google.com/personal-info)
2. Upload a profile picture

Avatars in Gmail only display in the mobile app (including in push notifications) and inside opened emails on desktop.

## Outlook

Follow these steps to add an avatar to your Outlook inbox:

1. Go to your [Outlook Profile Settings](https://account.microsoft.com/profile/)
2. Upload a profile picture

Avatars in Outlook only display in the mobile app and inside opened emails on desktop.

## Yahoo

Follow these steps to add an avatar to your Yahoo inbox:

1. Go to your [Yahoo Account Setting](https://login.yahoo.com/account/personalinfo)
2. Upload a profile picture

Avatars in Yahoo only display in the mobile app and inside an opened email on desktop.

## Apple Mail

Apple Mail only shows avatars if recipients have added images to contacts. Alternatively, you can set up [Apple Branded Mail](/knowledge-base/how-do-i-set-set-up-apple-branded-mail), a proprietary Apple format introduced with iOS 18.2 that displays your logo as an avatar in the inbox of Apple Mail, or [set up BIMI](/dashboard/domains/bimi#what-is-bimi) with a Verified Mark Certificate.

## Using Gravatar

Some inbox service providers or email clients (e.g. Thunderbird, Airmail, and Postbox) rely on [Gravatar](https://gravatar.com/) to display an image.

You can set up a free Gravatar account, add your avatar, and verify your addresses you're sending from to that account to have your avatar displayed.

## Limitations

Almost every email provider has its own way of adding a profile picture to an inbox.

This means **you can only**:

1. Add your avatar to a real inbox, limiting it only to that provider
2. Send mail from the same address that you set the avatar on

The way around this is [BIMI (Brand Indicators for Message Identification)](/dashboard/domains/bimi). BIMI now supports Common Mark Certificates (CMC) in addition to Verified Mark Certificates (VMC), making it more accessible. It is supported by nearly all major providers and allows you to send from any address on that domain.

<Note>
  Need assistance setting up BIMI? [We can help](https://resend.com/help).
</Note>


# How do I set up Apple Branded Mail?
Source: https://resend.com/docs/knowledge-base/how-do-i-set-set-up-apple-branded-mail

Learn how to implement Apple Branded Mail to display your logo in Apple Mail clients.

## Prerequisites

To get the most out of this guide, you will need to:

* [Create an Apple Business Connect account](https://www.apple.com/business/connect/)
* [Setup DMARC on your domain](/dashboard/domains/dmarc)
* A company identification number for Apple to verify your company

Prefer watching a video? Check out our video walkthrough below.

<YouTube />

## What is Apple Branded Mail?

Apple Branded Mail is a proprietary Apple format that displays your logo as an avatar in the inbox of Apple Mail. Displaying your logo can increase brand recognition and trust and improve engagement.

There are a few benefits of Apple Branded mail over BIMI:

* Since it's an Apple format, it does not require a certificate like [BIMI does](/dashboard/domains/bimi).
* The image support is broader, supporting `.png`, `.heif`, and `.jpg` logos.

Since Apple Branded Mail works only with Apple Mail on new iOS, iPadOS, and macOS versions, your logo will not show in other mail clients or older versions of Apple Mail.

For this reason, we recommend following all possible methods for adding your logo to your emails, including Apple Branded Mail, [our general guide](/knowledge-base/how-do-i-send-with-an-avatar), and [BIMI](/dashboard/domains/bimi) if it fits your needs.

## Implementing Apple Branded Mail

### 1. Configure DMARC

<Note>
  If you haven't set up DMARC yet, follow our [DMARC Setup
  Guide](/dashboard/domains/dmarc).
</Note>

To ensure your logo appears with Apple Branded Mail, set your DMARC policy to either `p=quarantine;` or `p=reject;`. This policy guarantees that your emails are authenticated and prevents others from spoofing your domain and sending emails with your logo.

Here's an overview of the required parameters:

| Parameter | Purpose    | Required Value                 |
| --------- | ---------- | ------------------------------ |
| `p`       | Policy     | `p=quarantine;` or `p=reject;` |
| `pct`     | Percentage | `pct=100;`                     |

Here is an example of an adequate DMARC record:

```
"v=DMARC1; p=quarantine; pct=100; rua=mailto:dmarcreports@example.com"
```

As we mention in our [DMARC Setup Guide](/dashboard/domains/dmarc), be sure to test your emails to make sure they are passing DMARC before changing your DMARC policy to `p=quarantine;` or `p=reject;`.

### 2. Create an Apple Business Connect account

Apple displays the logo you set in your Business Connect account. [Create an account](https://www.apple.com/business/connect/) if your company does not already have one. Make sure to use your company details when signing up.

### 3. Add your company details

Apple will prompt you to provide details like your company address and name.

### 4. Add your brand details

Once your company account is created, in Apple Business Connect, select the **Branded Mail** option in the left sidebar and provide details on your brand. Add details like the brand name and your brand website.

<img alt="Add your brand details" />

<img alt="Add your brand details" />

### 5. Add your logo

Once you fill out the brand details, upload your logo. Apple requires the logo to be at least 1024 x 1024 px in a `.png`, `.heif`, or `.jpeg` format.

<img alt="Add your logo" />

### 6. Add your domain

Confirm the domains or email addresses where you want your brand logo to appear.

You can register your logo for your root domain or a subdomain. If you don't set a specific logo for a subdomain, the root domain logo will automatically display for any email sent from your subdomains.

### 7. Verify your company

Apple requires details to confirm your company identity.

If you're in the United States, provide a Federal Taxpayer Identification Number. Other countries will use a local equivalent for this step. Apple also asks that you add a DNS record to verify DNS access.

### 8. Verify with Apple

After you submit all your information, Apple will verify your details. This process may take up to seven business days.

Once the logo is verified, Apple will send an email notification and note the verified status in Branded Mail. Your logo will start to display in compatible Apple Mail versions.

<img alt="Verified logo" />

<Tip>
  See Apple's documentation on [Apple Branded
  Mail](https://support.apple.com/en-au/guide/apple-business-connect/abcb761b19d2/web)
  for any detailed questions on adding your logo.
</Tip>


# How to Handle API Keys
Source: https://resend.com/docs/knowledge-base/how-to-handle-api-keys

Learn our suggested practices for handling API keys.

API Keys are secret tokens used to authenticate your requests. They are unique to your account and should be kept confidential. You can create API keys in two ways:

* [via the Resend Dashboard](/dashboard/api-keys/introduction)
* [via the API](/api-reference/api-keys/create-api-key)

<Info>
  For more help creating, deleting, and managing API keys, see the [API Keys
  documentation](/dashboard/api-keys/introduction).
</Info>

## Best Practices

It's crucial you handle your API keys securely. Do not share your API key with others or expose it in the browser or other client-side code.

Here are some general guidelines:

* Store API keys in environment variables.
* Never commit API keys to version control.
* Never hard-code API keys in your code or share them publicly.
* Rotate API keys regularly. If an API key hasn't been used in the last 30 days, consider deleting it to keep your account secure.

<Info>
  When you create an API key in Resend, you can view the key only once. This
  practice helps encourage these best practices.
</Info>

## Example

Many programming languages have built-in support for environment variables. Here's an example of how to store an API key in an environment variable in a Node.js application.

<Steps>
  <Step title="Create an environment variable">
    Once you create the API key, you can store it in an environment variable in a `.env` file.

    ```ts .env theme={null}
    RESEND_API_KEY = 're_xxxxxxxxx';
    ```
  </Step>

  <Step title="Add the file to your gitignore">
    Add the `.env` file to your `.gitignore` file to prevent it from being committed to version control. Many frameworks already add `.env` to the `.gitignore` file by default.

    ```ts .gitignore theme={null}
    .env
    ```
  </Step>

  <Step title="Use the environment variable in your code">
    ```ts app.ts theme={null}
    const resend = new Resend(process.env.RESEND_API_KEY);
    ```

    <Note>
      The environment variables in your `.env` file will *not* be available automatically. You *must* load them. On Node.js `v20` and later, you can pass your `.env` file's variables to your script using the `--env-file=.env` flag. Alternatively, you can use the `dotenv` package to load the variables.
    </Note>
  </Step>
</Steps>


# Introduction
Source: https://resend.com/docs/knowledge-base/introduction

A collection of answers to frequently asked questions.

<CardGroup>
  <Card title="Can I receive emails with Resend?" href="/dashboard/receiving/introduction">
    Learn how to receive emails with Resend
  </Card>

  <Card title="How do Dedicated IPs Work?" href="/knowledge-base/how-do-dedicated-ips-work">
    Learn how Dedicated IPs work and how to request them.
  </Card>

  <Card title="How do I avoid conflicts with my MX records?" href="/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records">
    Learn how to avoid conflicts with your existing MX records when setting up a
    Resend domain.
  </Card>

  <Card title="How do I avoid Gmail's spam folder?" href="/knowledge-base/how-do-i-avoid-gmails-spam-folder">
    Learn how to improve inbox placement in Gmail.
  </Card>

  <Card title="How do I avoid Outlook's spam folder?" href="/knowledge-base/how-do-i-avoid-outlooks-spam-folder">
    Learn how to improve inbox placement in Outlook.
  </Card>

  <Card title="How do I ensure sensitive data isn't stored on Resend?" href="/knowledge-base/how-do-i-ensure-sensitive-data-isnt-stored-on-resend">
    Information on how we can help you protect your customer's information.
  </Card>

  <Card title="How do I fix CORS issues?" href="/knowledge-base/how-do-i-fix-cors-issues">
    Information on recommended options to avoid CORS errors when sending emails.
  </Card>

  <Card title="How do I maximize deliverability for Supabase Auth emails?" href="/knowledge-base/how-do-i-maximize-deliverability-for-supabase-auth-emails">
    Everything you should do before you start sending authentication emails with
    Resend and Supabase.
  </Card>

  <Card title="How do I send with an avatar?" href="/knowledge-base/how-do-i-send-with-an-avatar">
    Learn how to show your avatar in the inbox of your recipients.
  </Card>

  <Card title="Is it better to send emails from a subdomain or the root domain?" href="/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain">
    Discover why sending emails from a subdomain can be better than using a root
    domain.
  </Card>

  <Card title="What if an email says delivered but the recipient hasn't received it?" href="/knowledge-base/what-if-an-email-says-delivered-but-the-recipient-has-not-received-it">
    Learn the steps to take when an email is delivered, but the recipient does not
    receive it.
  </Card>

  <Card title="What if my domain is not verifying?" href="/knowledge-base/what-if-my-domain-is-not-verifying">
    Learn what steps to take when your domain doesn't seem to verifying.
  </Card>

  <Card title="What is Resend Pricing?" href="/knowledge-base/what-is-resend-pricing">
    Learn more about Resend's pricing plans.
  </Card>

  <Card title="Why are my open rates not accurate?" href="/knowledge-base/why-are-my-open-rates-not-accurate">
    Learn why your open rate statistics are not accurate and what you can do about
    it.
  </Card>

  <Card title="How can I delete my Resend account?" href="/knowledge-base/how-can-i-delete-my-resend-account">
    Learn how to permanently delete your Resend account and data.
  </Card>

  <Card title="Should I add an unsubscribe link to all of my emails sent with Resend?" href="/knowledge-base/should-i-add-an-unsubscribe-link">
    Learn when to add unsubscribe links to your transactional and marketing
    emails.
  </Card>

  <Card title="Why are my emails landing on the suppression list?" href="/knowledge-base/why-are-my-emails-landing-on-the-suppression-list">
    Learn why your emails land on the suppression list, and how to remove them.
  </Card>
</CardGroup>


# IONOS
Source: https://resend.com/docs/knowledge-base/ionos

Verify your domain on IONOS with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to IONOS

Log in to your [IONOS account](https://my.ionos.com/domains):

1. Choose your Domain from the `Domain` list.
2. Select the `DNS` tab to get to the page to manage DNS records.

<img alt="Domain Details" />

## Add MX SPF Record

Select “Add record” on IONOS to copy and paste the values MX from Resend.

1. On the `Add a DNS Record` page, select `MX`.
2. Type `send` for the `Name` of the record.
3. Copy the MX Value from Resend into the `Points to` field.
4. Use the default `Priority` of `10`.
5. Use the default TTL of `1 hour`.
6. Select `Save`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to IONOS:

| IONOS     | Resend   | Example Value                           |
| --------- | -------- | --------------------------------------- |
| Type      | Type     | `MX Record`                             |
| Name      | Name     | `send`                                  |
| Points to | Value    | `feedback-smtp.us-east-1.amazonses.com` |
| TTL       | TTL      | `1 hour`                                |
| Priority  | Priority | `10`                                    |

<Info>
  Do not use the same priority for multiple records. If Priority `10` is already
  in use on another record, try a higher value `20` or `30`.
</Info>

## Add TXT SPF Record

In the same section, select “Add record” again.

1. On the `Add a DNS Record` page, select `TXT`.
2. Type `send` for the `Host name` of the record.
3. Copy the TXT Value Resend into the `TXT value` field.
4. Use the default TTL of `1 hour`.
5. Select `Save`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to IONOS:

| IONOS     | Resend | Example Value                         |
| --------- | ------ | ------------------------------------- |
| Type      | Type   | `TXT Record`                          |
| Host name | Name   | `send`                                |
| TXT value | Value  | `"v=spf1 include:amazonses.com ~all"` |
| TTL       | -      | `1 hour`                              |

## Add TXT DKIM Records

In the same section, select “Add record” again.

1. On the `Add a DNS Record` page, select `TXT`.
2. Type `resend._domainkey` for the `Host name` of the record.
3. Copy the record value from Resend into the `TXT value` field.
4. Use the default TTL of `1 hour`.
5. Select `Save`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to IONOS:

| IONOS     | Resend | Example Value                |
| --------- | ------ | ---------------------------- |
| Type      | Type   | `TXT Record`                 |
| Host name | Name   | `send`                       |
| TXT value | Value  | `p=example_demain_key_value` |
| TTL       | -      | `1 hour`                     |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

Select “Add record” on IONOS:

1. On the `Add a DNS Record` page, select `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Name` of the record.
3. Copy the MX Value from Resend into the `Points to` field.
4. Use the default `Priority` of `10`.
5. Use the default TTL of `1 hour`.
6. Select `Save`.

Below is a mapping of the record fields from Resend to IONOS:

| IONOS     | Resend   | Example Value                          |
| --------- | -------- | -------------------------------------- |
| Type      | Type     | `MX Record`                            |
| Name      | Name     | `inbound`                              |
| Points to | Content  | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL       | TTL      | `1 hour`                               |
| Priority  | Priority | `10`                                   |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to IONOS to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Is it better to send emails from a subdomain or the root domain?
Source: https://resend.com/docs/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain

Discover why sending emails from a subdomain can be better than using a root domain.

We recommend sending emails from a subdomain (`notifications.acme.com`) instead of your root/apex domain (`acme.com`).

There are **two main goals you should achieve with your domain setup**:

* Reputation Isolation
* Sending Purpose Transparency

## Reputation Isolation

Things happen. Maybe someone decides to DDOS your signup page and you get stuck sending tens of thousands of bounced verification emails to burner addresses. Or maybe a cold outreach campaign gets out of hand and your sending gets pegged as spam.

Whatever it is, you want to be consistently hedging your reputation. One way to do this is by not using your root domain. This allows you to quarantine a compromised subdomain if needed. If your root domain ends up with a jeopardized reputation, it can be a long road to recovery.

## Sending Purpose Transparency

All of us want all of our emails to go right to the top of the priority folder of the inbox, but the reality is, not all of our email should. A password reset email should have higher priority than a monthly product update. Inbox providers like Outlook and Gmail are constantly trying to triage incoming mail to put only the most important stuff in that priority spot, and move the rest towards Promotional or even Spam.

By segmenting your sending purposes by subdomain, you are giving Inbox Providers clear indication of how they should place your emails, which will build trust and confidence.

## Avoid "Lookalike" Domains

Never use domains that look like your main brand but aren’t actually your main brand. These brand-adjacent domains like `getacme-mail.com` or `acme-alerts.com` can appear suspicious to spam filters and confusing to your recipients. Inbox providers may flag them as phishing or spoofing attempts, and your users are more likely to ignore, delete, or even report the emails as spam.

If you’re launching a new project or sending for a different purpose, again use a subdomain of your main domain. Sticking with clear, consistent subdomains helps reinforce your brand identity and builds trust with inbox providers and recipients alike.

<Note>
  We cover this in depth in our [deliverability
  guide](/knowledge-base/how-do-i-avoid-gmails-spam-folder#establish-sending-patterns).
</Note>


# Send emails with Leap and Resend
Source: https://resend.com/docs/knowledge-base/leap-new-integration

Learn how to add the Resend integration to your Leap.new project.

[Leap](https://leap.new) is a platform for building full-stack web and mobile apps via chat.

## 1. Ask Leap to add Resend

You can add Resend in a Leap project by asking the chat to add email sending with Resend.

**Example prompt**

```
When someone fills out the contact form, send an email using Resend.
```

## 2. Add your Resend API key

To use Resend with Leap, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

Leap will prompt you to set a secret value on the Infrastructure page. Paste your key value and click **Update secret**.

<img alt="adding the Resend integration to a leap.new chat" />

<Info>
  Learn more about the Resend integration in the [Leap
  documentation](https://docs.leap.new/integrations/resend).
</Info>

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

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

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](https://resend.com/domains).
2. Add the custom domain to the `from` field in the `resend` function in Leap (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/dashboard/domains/introduction).


# Send emails with Lovable and Resend
Source: https://resend.com/docs/knowledge-base/lovable-integration

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

[Lovable](https://lovable.dev) is a platform for building web sites, tools, apps, and projects via chat. You can add Resend in a Lovable project by asking the chat to add email sending with Resend.

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

<YouTube />

## 1. Add your Resend API key

To use Resend with Lovable, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

Lovable may integrate Resend in a few different ways:

* Use the Supabase integration to store the API key **(highly recommended)**
* Ask users to provide their own API key
* Add the API key directly in the code

You may need to prompt Lovable to store the API key for Resend using Supabase. Clicking **Add API key** will open a modal where you can add the API key.

<img alt="adding the Resend integration to a Lovable chat" />

<Info>
  At the time of writing, Lovable does not securely handle API keys
  independently. Instead, it uses the [Supabase integration to store
  secrets](https://docs.lovable.dev/integrations/supabase#storing-secrets-api-keys-%26-config).
</Info>

## 2. Add a custom domain to your Resend account

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

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](https://resend.com/domains).
2. Add the custom domain to the `from` field in the `resend` function in Lovable (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/dashboard/domains/introduction).


# MCP Server
Source: https://resend.com/docs/knowledge-base/mcp-server

Learn how to use the MCP Server to send emails.

## What is an MCP Server?

MCP is an open protocol that standardizes how applications provide context to LLMs. Among other benefits, it provides LLMs tools to act on your behalf.

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

<YouTube />

## What can Resend's MCP Server do?

Currently, Resend's MCP Server is a simple server you must build locally that can send emails using Resend's API on your behalf.

* Send plain text and HTML emails
* Schedule emails for future delivery
* Add CC and BCC recipients
* Configure reply-to addresses
* Customizable sender email (requires verification)

As an example, you could use this to run local scripts, chat with Claude, or process data and send the results to yourself or your team.

<video />

## How to use Resend's MCP Server

Build the project locally to use this MCP server to use it in a [supported MCP client](#mcp-client-integrations).

<Steps>
  <Step title="Clone this project locally.">
    ```bash theme={null}
    git clone https://github.com/resend/mcp-send-email.git
    ```
  </Step>

  <Step title="Build the project">
    ```
    npm install
    npm run build
    ```
  </Step>

  <Step title="Setup Resend">
    1. [Create an API Key](https://resend.com/api-keys): copy this key to your clipboard
    2. [Verify your own domain](https://resend.com/domains): to send to email addresses other than your own
  </Step>
</Steps>

## MCP Client Integrations

With the MCP server built, you can now add it to a supported MCP client.

### Cursor

<Steps>
  <Step title="Open Cursor Settings">
    Open the command palette (`cmd`+`shift`+`p` on macOS or `ctrl`+`shift`+`p` on Windows) and choose **Cursor Settings**.
  </Step>

  <Step title="Add the MCP server">
    Select **MCP** from the left sidebar and click **Add new global MCP server** and add the following config:

    ```json theme={null}
    {
      "mcpServers": {
        "resend": {
          "type": "command",
          "command": "node ABSOLUTE_PATH_TO_MCP_SEND_EMAIL_PROJECT/build/index.js --key=YOUR_RESEND_API_KEY"
        }
      }
    }
    ```

    You can get the absolute path to your build script by right-clicking on the `/build/index.js` file in Cursor and selecting `Copy Path`.

    **Possible arguments**

    * `--key`: Your Resend API key (required)
    * `--sender`: Your sender email address from a verified domain (optional)
    * `--reply-to`: Your reply-to email address (optional)

    <Info>
      If you don't provide a sender email address, the MCP server will ask you to
      provide one each time you call the tool.
    </Info>

    Adding the MCP server to Cursor's global settings will let you send emails from any project on your machine using Cursor's Agent mode.
  </Step>

  <Step title="Test the sending">
    Test sending emails by going to `email.md` in the cloned project.

    * Replace the to: email address with your own
    * Select all text in `email.md`, and press `cmd+l`
    * Tell cursor to "send this as an email" in the chat (make sure cursor is in Agent mode by selecting "Agent" on lower left side dropdown).

    <img alt="Cursor chat with email.md file selected and Agent mode enabled" />
  </Step>
</Steps>

### Claude Desktop

<Steps>
  <Step title="Open Claude Desktop settings">
    Open Claude Desktop settings and navigate to the "Developer" tab. Click `Edit Config`.
  </Step>

  <Step title="Add the MCP server">
    Add the following config:

    ```json theme={null}
    {
      "mcpServers": {
        "resend": {
          "command": "node",
          "args": ["ABSOLUTE_PATH_TO_MCP_SEND_EMAIL_PROJECT/build/index.js"],
          "env": {
            "RESEND_API_KEY": "YOUR_RESEND_API_KEY"
          }
        }
      }
    }
    ```

    You can get the absolute path to your build script by right-clicking on the `/build/index.js` file in your IDE and selecting `Copy Path`.

    **Possible environment variables**

    * `RESEND_API_KEY`: Your Resend API key (required)
    * `SENDER_EMAIL_ADDRESS`: Your sender email address from a verified domain (optional)
    * `REPLY_TO_EMAIL_ADDRESS`: Your reply-to email address (optional)

    <Info>
      If you don't provide a sender email address, the MCP server will ask you to
      provide one each time you call the tool.
    </Info>
  </Step>

  <Step title="Test the server">
    Close and reopen Claude Desktop. Verify that the `resend` tool is available in the Claude developer settings.

    <img alt="Claude Desktop developer settings with Resend MCP server showing" />

    Chat with Claude and tell it to send you an email using the `resend` tool.
  </Step>
</Steps>


# Namecheap
Source: https://resend.com/docs/knowledge-base/namecheap

Verify your domain on Namecheap with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to Namecheap

1. Log in to your [Namecheap account](https://ap.www.namecheap.com).

2. Click `Manage` for the domain.

   <img alt="Domain Details" />

   <Info>You may need to expand a dropdown to see the `Manage` button.</Info>

3. Go to the `Advanced DNS` page for the domain you want to verify.

   <img alt="Domain Details" />

## Add MX SPF Record

<Warning>
  If you are changing the MX configuration from `Gmail` to `Custom MX`, you need
  to [setup new MX records for
  Gmail](https://support.google.com/a/answer/174125). If you don't setup new
  records, receiving mail in your gmail inboxes will stop.
</Warning>

Under the `Mail Settings` section, click the dropdown and select `Custom MX`:

1. Type `send` for the `Host` of the record.
2. Copy the MX Value from Resend into the `Value` field.
3. Use the `Automatic` TTL.
4. Select `Save all changes`.

<img alt="Domain Details" />

<br />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Namecheap:

| Namecheap | Resend   | Example Value                           |
| --------- | -------- | --------------------------------------- |
| Type      | Type     | `MX Record`                             |
| Host      | Name     | `send`                                  |
| TTL       | TTL      | `Automatic`                             |
| Value     | Value    | `feedback-smtp.us-east-1.amazonses.com` |
| -         | Priority | `10`                                    |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<Info>
  Namecheap does not label the `priority` column. It is the empty column after
  `Value`. Do not use the same priority for multiple records. If Priority `10`
  is already in use, try a higher value `20` or `30`.
</Info>

## Add TXT SPF Record

Under the `Host Records` section, click `Add New Record`:

1. Set the `Type` to `TXT Record`.
2. Enter `send` into the `Host` field.
3. Copy the TXT Value from Resend into the `Value` field.
4. Use the `Automatic` TTL.
5. Select `Save all changes`.

<img alt="Domain Details" />

<br />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Namecheap:

| Namecheap | Resend | Example Value                         |
| --------- | ------ | ------------------------------------- |
| Type      | Type   | `TXT Record`                          |
| Host      | Name   | `send`                                |
| TTL       | TTL    | `Automatic`                           |
| Value     | Value  | `"v=spf1 include:amazonses.com ~all"` |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

## Add TXT DKIM Records

In that same `Host Records` section, click `Add New Record`.

1. Set the `Type` to `TXT Record`.
2. Enter `resend._domainkey` into the `Host` field.
3. Copy the TXT Value from Resend into the `Value` field.
4. Use the `Automatic` TTL.
5. Select `Save all changes`.

<img alt="Domain Details" />

<br />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Namecheap:

| Namecheap | Resend | Example Value                |
| --------- | ------ | ---------------------------- |
| Type      | Type   | `TXT Record`                 |
| Host      | Name   | `resend._domainkey`          |
| TTL       | TTL    | `Automatic`                  |
| Value     | Value  | `p=example_demain_key_value` |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

Under the `Mail Settings` section, click the dropdown and select `Custom MX`:

1. Type `inbound` (or whatever your subdomain is) for the `Host` of the record.
2. Copy the MX Value from Resend into the `Value` field.
3. Use the `Automatic` TTL.
4. Select `Save all changes`.

Below is a mapping of the record fields from Resend to Namecheap:

| Namecheap | Resend   | Example Value                          |
| --------- | -------- | -------------------------------------- |
| Type      | Type     | `MX Record`                            |
| Host      | Name     | `inbound`                              |
| TTL       | TTL      | `Automatic`                            |
| Value     | Content  | `inbound-smtp.us-east-1.amazonaws.com` |
| -         | Priority | `10`                                   |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take up to 72 hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Namecheap to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Porkbun
Source: https://resend.com/docs/knowledge-base/porkbun

Verify your domain on Porkbun with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to Porkbun

Log in to your [Porkbun account](https://porkbun.com/account/domainsSpeedy):

1. Select the `DNS` option under your domain to manage DNS records.

<img alt="Domain Details" />

## Add MX SPF Record

In the `DNS` section on Porkbun copy and paste the values MX from Resend:

1. On the `Type` page, choose `MX`.
2. Type `send` for the `Host` of the record.
3. Copy the MX Value from Resend into the `Answer / Value` field.
4. Use the default TTL of `600`.
5. In the `Priority` field enter `10`.
6. Select `Add`.

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Porkbun:

| Porkbun        | Resend   | Example Value                           |
| -------------- | -------- | --------------------------------------- |
| Type           | Type     | `MX Record`                             |
| Host           | Name     | `send`                                  |
| Answer / Value | Value    | `feedback-smtp.us-east-1.amazonses.com` |
| TTL            | TTL      | `600`                                   |
| Priority       | Priority | `10`                                    |

<Info>
  Do not use the same priority for multiple records. If Priority `10` is already
  in use on another record, try a higher value `20` or `30`.
</Info>

## Add TXT SPF Record

On the same section:

1. On the `Type` page, choose `TXT`.
2. Type `send` for the `Host` of the record.
3. Copy the TXT Value Resend into the `Answer / Value` field.
4. Use the default TTL of `600`.
5. Select `Add Record`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Porkbun:

| Porkbun        | Resend | Example Value                         |
| -------------- | ------ | ------------------------------------- |
| Type           | Type   | `TXT Record`                          |
| Host           | Name   | `send`                                |
| Answer / Value | Value  | `"v=spf1 include:amazonses.com ~all"` |
| TTL            | TTL    | `600`                                 |

## Add TXT DKIM Records

On the same `Create Record` section:

1. On the `Type` page, choose `TXT`.
2. Type `resend._domainkey` for the `Host` of the record.
3. Copy the TXT Value Resend into the `Answer / Value` field.
4. Use the default TTL of `600`.
5. Select `Add Record`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Porkbun:

| Porkbun        | Resend | Example Value                |
| -------------- | ------ | ---------------------------- |
| Type           | Type   | `TXT Record`                 |
| Host           | Name   | `send`                       |
| Answer / Value | Value  | `p=example_demain_key_value` |
| TTL            | TTL    | `600`                        |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

In the `DNS` section on Porkbun:

1. On the `Type` page, choose `MX`.
2. Type `inbound` (or whatever your subdomain is) for the `Host` of the record.
3. Copy the MX Value from Resend into the `Answer / Value` field.
4. Use the default TTL of `600`.
5. In the `Priority` field enter `10`.
6. Select `Add`.

Below is a mapping of the record fields from Resend to Porkbun:

| Porkbun        | Resend   | Example Value                          |
| -------------- | -------- | -------------------------------------- |
| Type           | Type     | `MX Record`                            |
| Host           | Name     | `inbound`                              |
| Answer / Value | Content  | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL            | TTL      | `600`                                  |
| Priority       | Priority | `10`                                   |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Porkbun to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Send emails with Replit and Resend
Source: https://resend.com/docs/knowledge-base/replit-integration

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

[Replit](https://replit.com/) is a platform for building sites and apps with AI. You can add Resend in a Replit project by asking the chat to add email sending with Resend.

**Example prompt**

```
When someone fills out the contact form, send an email using Resend.
```

Prefer watching a video? Check out our video walkthrough below.

<YouTube />

## 1. Add a custom domain to your Resend account

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

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](https://resend.com/domains).
2. Add the custom domain to the `from` field in the `resend` function in Replit (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/dashboard/domains/introduction).

## 2. Add your Resend API key and from address

To use Resend with Replit, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys). Do not share your API key with others or expose it in the browser or other client-side code.

The from address is the email address that will be used to send emails. Use your custom domain you added in step 1 here (e.g., `hello@yourdomain.com`).

<img alt="adding the Resend integration to a Replit chat" />

<Note>
  Replit tracks the details of your Resend integration in the [Integrations
  page](https://replit.com/integrations).
</Note>


# AWS Route 53
Source: https://resend.com/docs/knowledge-base/route53

Verify your domain on Route 53 with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to Route 53

Then, log in to your [AWS Management Console, and open Route 53 console](https://console.aws.amazon.com/route53/), then click on your domain name. From there, click on `Create Record`.

<img alt="Domain Details" />

## Add MX SPF Record

1. Type in `send` for the `Record name`.
2. Select the `Record type` dropdown, and choose `MX`.
3. Copy the MX Value from your domain in Resend into the `Value` field.
4. Be sure to include the `10` in the `Value` field, as seen in the screenshot.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Route 53:

| Route 53       | Resend           | Example Value                              |
| -------------- | ---------------- | ------------------------------------------ |
| Record Type    | Type             | `MX Record`                                |
| Record name    | Name             | `send`                                     |
| Value          | Value & Priority | `10 feedback-smtp.us-east-1.amazonses.com` |
| TTL            | TTL              | `Use Route 53 Default (300)`               |
| Routing policy | -                | `Simple routing`                           |

<Info>
  Route 53 does not label the `priority` column, and you will need to add this
  in to the `Value` section, as shown in the screenshot. Do not use the same
  priority for multiple records. If Priority `10` is already in use, try a
  number slightly higher like `11` or `12`.
</Info>

## Add TXT SPF Record

In the same section, choose `Add another record`:

1. Type in `send` for the `Record name`.
2. Click the `Record type` dropdown.
3. Select the `Record type` dropdown, and choose `TXT`.
4. Copy TXT Value from your domain in Resend into the `Value` field.

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Route 53:

| Route 53       | Resend | Example Value                         |
| -------------- | ------ | ------------------------------------- |
| Record type    | Type   | `TXT Record`                          |
| Record name    | Name   | `send`                                |
| Value          | Value  | `"v=spf1 include:amazonses.com ~all"` |
| TTL            | TTL    | `Use Route 53 Default (300)`          |
| Routing policy | -      | `Simple routing`                      |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

## Add TXT DKIM Records

In the same section, choose `Add another record`:

1. Type in `resend._domainkey` for the the `Record name`.
2. Change the `Record Type` to `TXT`.
3. Copy the TXT Value value from your domain in Resend to the `Value` text box.
4. Click on `Create Records`.

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Route 53:

| Route 53       | Resend | Example Value                |
| -------------- | ------ | ---------------------------- |
| Record type    | Type   | `TXT Record`                 |
| Record name    | Name   | `resend._domainkey`          |
| Value          | Value  | `p=example_demain_key_value` |
| TTL            | TTL    | `Use Route 53 Default (300)` |
| Routing policy | -      | `Simple routing`             |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

In the Route 53 console, click `Create Record`:

1. Type in `inbound` (or whatever your subdomain is) for the `Record name`.
2. Select the `Record type` dropdown, and choose `MX`.
3. Copy the MX Value from your domain in Resend into the `Value` field.
4. Be sure to include the `10` in the `Value` field (e.g., `10 inbound-smtp.us-east-1.amazonaws.com`).

Below is a mapping of the record fields from Resend to Route 53:

| Route 53       | Resend             | Example Value                             |
| -------------- | ------------------ | ----------------------------------------- |
| Record Type    | Type               | `MX Record`                               |
| Record name    | Name               | `inbound`                                 |
| Value          | Content & Priority | `10 inbound-smtp.us-east-1.amazonaws.com` |
| TTL            | TTL                | `Use Route 53 Default (300)`              |
| Routing policy | -                  | `Simple routing`                          |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take up to 5 hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Route 53 to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# How to prevent bounces with @privaterelay.appleid.com recipients?
Source: https://resend.com/docs/knowledge-base/sending-apple-private-relay

Sending to Apple Private Email Relay requires specific configuration steps to ensure your emails get delivered

If your website or application supports Sign In with Apple, your customers have the option to receive emails from you via Apple’s Private Email Relay service. This feature allows users to keep their actual email addresses private when they sign up or log in.

When a user selects the Hide My Email option, Apple assigns them a unique, randomly generated email address under the `@privaterelay.appleid.com` domain, which you can link to that specific user.

To ensure your emails are delivered through Apple’s Private Email Relay, you must first access the Apple Developer Portal and navigate to `Certificates, Identifiers & Profiles` > `More` > `Sign in with Apple for Email Communication` > `Configure`.

<Info>
  **Apple Offers Multiple Hide My Email Services**

  Starting with iOS 15, Apple provides two separate Hide My Email services—one through Sign in with Apple and another via iCloud+.

  This guide is specifically for apps and websites utilizing Sign in with Apple, which generates a unique email address for account creation and login purposes.
</Info>

## Register your sending domains

Apple mandates that you list the domains from which you will send emails to its service. Additionally, if your return-path domain differs from your sending domain, you must include that as well.

If you use Resend, note that its return-path domain is different since it operates through a subdomain. You will find this subdomain in your Domain settings, formatted as `send.yourdomain.tld` or `send.yoursubdomain.yourdomain.tld` for MX and SPF records. Ensure you add both your primary domain and the subdomain as Apple Email Sources.

## Register your email addresses

Alongside your Sending Domains, Apple requires registration of all email addresses used to send messages from those domains.

You can add these email addresses one by one or in a comma-separated list. If you use other email sources outside of Resend to send messages to Private Relay addresses, include those as well.

## Authenticate your sending domains

Since Resend mandates SPF and DKIM authentication for all domains sending emails through its service, your domain will automatically meet Apple’s authentication requirements.

## Still experiencing bounces from @privaterelay.appleid.com?

At times, emails sent to `@privaterelay.appleid.com` may still bounce. While the bounce messages may not always contain detailed explanations, common reasons include:

* The user has deleted their Hide My Email address from Apple’s settings.
* The user has exceeded their daily limit of 100 emails sent to and from their Hide My Email address.
* A misconfiguration in your settings—double-check that all Sending Domains and From Addresses are correctly registered and authenticated with Apple.

Apple allows the account owner and admins in the Apple Developer Portal to receive notifications if messages fail to deliver through the relay. You can enable this setting in the portal.

***

Once you have completed these three steps, you will be ready to send emails to customers using Hide My Email addresses via Apple’s Private Email Relay service.

For additional details on Apple Private Email Relay and configuration options, refer to Apple’s official documentation:

* [Apple: Configure Private Email Relay Service](https://developer.apple.com/help/account/configure-app-capabilities/configure-private-email-relay-service/)
* [Apple: Communicating Using the Private Email Relay Service](https://developer.apple.com/documentation/signinwithapple/communicating-using-the-private-email-relay-service/)


# Should I add an unsubscribe link to all of my emails sent with Resend?
Source: https://resend.com/docs/knowledge-base/should-i-add-an-unsubscribe-link

Learn best practices about using unsubscribe links.

Transactional emails are generally exempt from including an unsubscribe link. Unlike marketing emails, transactional emails serve a functional purpose, such as account confirmation, password resets, and order confirmations.

As a best practice, we recommend telling recipients how to opt out of receiving future email from you if the content is more related to nurturing relationships with your customers, rather than pragmatic, action-oriented emails.

Laws enforced by the FTC and GDPR prioritize giving recipients an easy way to give and withdraw their consent to receiving email marketing content. Additionally, not having an option for opting out of emails risks recipients complaining or marking the email as spam, which can hurt your reputation as a sender.

Here is more on how to [manually add and manage unsubscribe links](https://resend.com/docs/dashboard/emails/add-unsubscribe-to-transactional-emails).

If you're using [Resend Broadcasts](https://resend.com/docs/dashboard/audiences/managing-unsubscribe-list), the unsubscribe headers are added automatically to your emails. You can include the Unsubscribe Footer in your Broadcasts, which will be automatically replaced with the correct link for each contact or use `{{{RESEND_UNSUBSCRIBE_URL}}}` as a link target should you want to customize the unsubscribe footer.


# Squarespace
Source: https://resend.com/docs/knowledge-base/squarespace

Verify your domain on Squarespace with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to Squarespace

Log in to your [Squarespace domains page](https://account.squarespace.com/domains) and click on your domain.

<img alt="Domain Details" />

## Add MX SPF Record

Scroll down to the **Custom records** section and select `Add record` on Squarespace.

1. Type `send` for the `Host` of the record.
2. Set the `Type` to `MX`.
3. Set the `Priority` to `10`.
4. Use the Default 4 hours for `TTL`.
5. Copy the MX Value from Resend into the `Mail Server` field
6. Select `Save`.

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Squarespace:

| Squarespace | Resend   | Example Value                           |
| ----------- | -------- | --------------------------------------- |
| Type        | Type     | `MX`                                    |
| Host        | Name     | `send`                                  |
| TTL         | TTL      | `4 hrs` (default)                       |
| Mail Server | Value    | `feedback-smtp.us-east-1.amazonses.com` |
| Priority    | Priority | `10`                                    |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<Info>
  Do not use the same priority for multiple records. If Priority `10` is already
  in use, try a higher value `20` or `30`.
</Info>

## Add TXT SPF Record

In the same **Custom records** section, select `Add Record` on Squarespace.

1. Type `send` for the `Host` of the record.
2. Set the `Type` to `TXT`.
3. Use the Default 4 hours for `TTL`.
4. Copy the TXT Value from Resend into the `Text` field
5. Select `Save`.

Add the **TXT Record** from your domain in Resend to Squarespace and click "Save".

<img alt="Domain Details" />

<br />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Squarespace:

| Squarespace | Resend | Example Value                         |
| ----------- | ------ | ------------------------------------- |
| Type        | Type   | `TXT`                                 |
| Host        | Name   | `send`                                |
| TTL         | TTL    | `4 hrs` (default)                     |
| Text        | Value  | `"v=spf1 include:amazonses.com ~all"` |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

## Add TXT DKIM Records

In the same **Custom records** section, select `Add Record` on Squarespace.

1. Type `resend._domainkey` for the `Host` of the record.
2. Set the `Type` to `TXT`.
3. Use the Default 4 hours for `TTL`.
4. Copy the TXT Value from Resend into the `Text` field
5. Select `Save`.

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Squarespace:

| Squarespace | Resend | Example Value                |
| ----------- | ------ | ---------------------------- |
| Type        | Type   | `TXT`                        |
| Host        | Name   | `resend._domainkey`          |
| TTL         | TTL    | `4 hrs` (default)            |
| Text        | Value  | `p=example_demain_key_value` |

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

Scroll down to the **Custom records** section and select `Add record` on Squarespace:

1. Type `inbound` (or whatever your subdomain is) for the `Host` of the record.
2. Set the `Type` to `MX`.
3. Set the `Priority` to `10`.
4. Use the Default 4 hours for `TTL`.
5. Copy the MX Value from Resend into the `Mail Server` field.
6. Select `Save`.

Below is a mapping of the record fields from Resend to Squarespace:

| Squarespace | Resend   | Example Value                          |
| ----------- | -------- | -------------------------------------- |
| Type        | Type     | `MX`                                   |
| Host        | Name     | `inbound`                              |
| TTL         | TTL      | `4 hrs` (default)                      |
| Mail Server | Content  | `inbound-smtp.us-east-1.amazonaws.com` |
| Priority    | Priority | `10`                                   |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take up to 72 hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Squarespace to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Strato
Source: https://resend.com/docs/knowledge-base/strato

Verify your domain on Strato with Resend.

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to Strato

Log in to your [Strato account](https://www.strato.es/apps/CustomerService):

1. In the left-hand navigation, go to Domains > Manage Domain.

<img alt="Domain Details" />

## Add MX SPF Record

1. On the domain page, click on the gear icon to redirect to Settings.
2. Create a new subdomain named `send`.
3. Navigate to the subdomain settings.
4. Go to the `DNS` tab, you'll see a list of DNS records you can update. Click on `manage` MX record.
5. Select own mail server.
6. Copy MX value from Resend into `Server` field.
7. Use the default priority `Low`.
8. Save settings.

<Info>
  By default, Strato domains use Strato mail server which uses `mail` as their
  send path. You will need to bypass this default behavior by creating a
  subdomain and setting the MX record there.
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Strato:

| Strato      | Resend   | Example Value                            |
| ----------- | -------- | ---------------------------------------- |
| Type        | Type     | `MX Record`                              |
| Name        | Name     | `send`                                   |
| Mail server | Value    | `feedback-smtp.eu-west-1.amazonses.com.` |
| Priority    | Priority | `Low`                                    |

## Add TXT SPF Record

On the base domain settings:

1. Go to the `DNS` tab.
2. Manage TXT and CNAME records.
3. On the bottom, click `Create another record`.
4. Choose `TXT` type.
5. Add `send` for the `name` record.
6. For `value` input `v=spf1 include:amazonses.com ~all`.
7. Save settings.

<Info>
  Strato provides a standard DMARC record similar to Resend's recommended value:
  `v=DMARC1;p=reject;`.
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Strato:

| Strato | Resend | Example Value                       |
| ------ | ------ | ----------------------------------- |
| Type   | Type   | `TXT Record`                        |
| Name   | Name   | `send`                              |
| Value  | Value  | `v=spf1 include:amazonses.com ~all` |

## Add TXT DKIM Records

On the same TXT and CNAME manage page:

1. Click `Create another record`.
2. Choose `TXT` type.
3. Add `resend._domainkey` for the `Name` record.
4. Copy the record value from Resend into the TXT value field.
5. Save settings.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Strato:

| Strato | Resend | Example Value                |
| ------ | ------ | ---------------------------- |
| Type   | Type   | `TXT Record`                 |
| Name   | Name   | `send`                       |
| Value  | Value  | `p=example_demain_key_value` |

<Info>
  Copy DKIM value using the small copy icon in Resend. DKIM records are
  case-sensitive and must match up exactly.
</Info>

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

1. Create a new subdomain named `inbound` (or whatever your subdomain is).
2. Navigate to the subdomain settings.
3. Go to the `DNS` tab and click on `manage` MX record.
4. Select own mail server.
5. Copy MX value from Resend into `Server` field.
6. Use the default priority `Low`.
7. Save settings.

Below is a mapping of the record fields from Resend to Strato:

| Strato      | Resend   | Example Value                           |
| ----------- | -------- | --------------------------------------- |
| Type        | Type     | `MX Record`                             |
| Name        | Name     | `inbound`                               |
| Mail server | Content  | `inbound-smtp.us-east-1.amazonaws.com.` |
| Priority    | Priority | `Low`                                   |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Strato to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Send emails with v0 and Resend
Source: https://resend.com/docs/knowledge-base/v0-integration

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

[v0](https://v0.dev) by Vercel is a platform for building web sites, tools, apps, and projects via chat. You can add Resend in a v0 project by asking the chat to add email sending with Resend.

## 1. Add your Resend API key

To use Resend with v0, you'll need to add a Resend API key, which you can create in the [Resend Dashboard](https://resend.com/api-keys).

<Note>
  Do not share your API key with others or expose it in the browser or other
  client-side code.
</Note>

<img alt="adding the Resend integration to a v0 chat" />

## 2. Add a custom domain to your Resend account

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

To send emails to other email addresses:

1. Add a [custom domain to your Resend account](https://resend.com/domains).
2. Add the custom domain to the `from` field in the `resend` function in v0 (or ask the chat to update these fields).

Get more help adding a custom domain in [Resend's documentation](/dashboard/domains/introduction).


# Vercel
Source: https://resend.com/docs/knowledge-base/vercel

Verify your domain on Vercel with Resend.

<Note>
  This guide helps you verify your domain on Vercel with Resend. We also have
  [an official integration for
  Vercel](https://resend.com/blog/vercel-integration) that helps you set up your
  API keys on Vercel projects so you can start sending emails with Resend. [View
  the integration here](https://vercel.com/resend/~/integrations/resend).
</Note>

## Add Domain to Resend

First, log in to your [Resend Account](https://resend.com/login) and [add a domain](https://resend.com/domains).

<img alt="Domain Details" />

<Tip>
  It is [best practice to use a
  subdomain](/knowledge-base/is-it-better-to-send-emails-from-a-subdomain-or-the-root-domain)
  (updates.example.com) instead of the root domain (example.com). Using a
  subdomain allows for proper reputation segmentation based on topics or purpose
  (e.g. marketing) and is especially important if receiving emails with Resend.
</Tip>

## Log in to Vercel

Log in to your [Vercel account](https://vercel.com/login) and select the `Domains` tab.

<img alt="Domain Details" />

## Add MX SPF Record

Copy and paste the values in Resend to Vercel.

1. Type `send` for the `Name` of the record in Vercel.
2. Expand the `Type` dropdown and select `MX`.
3. Copy the record value from Resend into the `Value` field in Vercel.
4. Add `10` for the `Priority`.
5. Select `Add`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Vercel:

| Vercel   | Resend   | Example Value                           |
| -------- | -------- | --------------------------------------- |
| Type     | Type     | `MX Record`                             |
| Name     | Name     | `send`                                  |
| Value    | Value    | `feedback-smtp.us-east-1.amazonses.com` |
| TTL      | TTL      | `Use Vercel default (60)`               |
| Priority | Priority | `10`                                    |

<Info>
  Do not use the same priority for multiple records. If Priority `10` is already
  in use on another record, try a higher value `20` or `30`.
</Info>

## Add TXT SPF Record

In the same section, add another record in Vercel.

1. Type `send` for the `Name` of the record.
2. Expand the `Type` dropdown and select `TXT`.
3. Copy the `TXT` record value from Resend into the `Value` field in Vercel.
4. Use the default TTL of `60`.
5. Select `Add`.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `send.example.com`, paste only `send` (or `send.subdomain` if you're using a
  subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Vercel:

| Vercel | Resend | Example Value                         |
| ------ | ------ | ------------------------------------- |
| Type   | Type   | `TXT Record`                          |
| Name   | Name   | `send`                                |
| Value  | Value  | `"v=spf1 include:amazonses.com ~all"` |
| TTL    | TTL    | `Use Vercel default (60)`             |

## Add TXT DKIM Records

In the same section, add another record in Vercel.

1. Type `resend._domainkey` for the `Name` of the record.
2. Expand the `Type` dropdown and select `TXT`.
3. Copy the record value from Resend into the `Value` field in Vercel.

<Info>
  Omit your domain from the record values in Resend when you paste. Instead of
  `resend._domainkey.example.com`, paste only `resend._domainkey` (or
  `resend._domainkey.subdomain` if you're using a subdomain).
</Info>

<img alt="Domain Details" />

<img alt="Domain Details" />

Below is a mapping of the record fields from Resend to Vercel:

| Vercel | Resend | Example Value                |
| ------ | ------ | ---------------------------- |
| Type   | Type   | `TXT Record`                 |
| Name   | Name   | `resend._domainkey`          |
| Value  | Value  | `p=example_demain_key_value` |
| TTL    | TTL    | `Use Vercel default (60)`    |

## Receiving Emails

If you want to receive emails at your domain, toggle the "Receiving" switch on the domain details page.

<img alt="Enable Receiving Emails for a verified domain" />

<Warning>
  When you enable Inbound on a domain, Resend receives *all emails* sent to that
  specific domain depending on the priority of the MX record. For this reason,
  we strongly recommend verifying a subdomain (`subdomain.example.com`) instead
  of the root domain (`example.com`). Learn more about [avoiding conflicts with
  your existing MX
  records](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Warning>

Copy and paste the values in Resend to Vercel:

1. Type `inbound` (or whatever your subdomain is) for the `Name` of the record in Vercel.
2. Expand the `Type` dropdown and select `MX`.
3. Copy the MX Value from Resend into the `Value` field in Vercel.
4. Add `10` for the `Priority`.
5. Select `Add`.

Below is a mapping of the record fields from Resend to Vercel:

| Vercel   | Resend   | Example Value                          |
| -------- | -------- | -------------------------------------- |
| Type     | Type     | `MX Record`                            |
| Name     | Name     | `inbound`                              |
| Value    | Content  | `inbound-smtp.us-east-1.amazonaws.com` |
| TTL      | TTL      | `Use Vercel default (60)`              |
| Priority | Priority | `10`                                   |

After verifying your domain, create a webhook to process incoming emails. For help setting up a webhook, how to access email data and attachments, forward emails, and more, see [our guide on receiving emails with Resend](/dashboard/receiving/introduction).

## Complete Verification

Now click [Verify DNS Records](https://resend.com/domains) on your Domain in Resend. It may take a few hours to complete the verification process (often much faster).

## Troubleshooting

If your domain is not successfully verified, these are some common troubleshooting methods.

<AccordionGroup>
  <Accordion title="Resend shows my domain verification failed.">
    Review the records you added to Vercel to rule out copy and paste errors.
  </Accordion>

  <Accordion title="It has been longer than 72 hours and my domain is still Pending.">
    [Review our guide on a domain not verifying](/knowledge-base/what-if-my-domain-is-not-verifying).
  </Accordion>
</AccordionGroup>


# Domain and/or IP Warm-up Guide
Source: https://resend.com/docs/knowledge-base/warming-up

Learn how to warm up a domain or IP to avoid deliverability issues.

Warming up a domain or IP refers to the practice of progressively increasing your sending volume to maximize your deliverability. The goal is to send at a consistent rate and avoid any spikes in email volume that might be concerning to inbox service providers.

Whenever you change your sending patterns—whether because you're using a new domain, a new IP, or a new vendor, or because your volume will increase—you should warm-up your domain and/or IP.

A thought-out warm-up plan limits greylisting and delivery throttling, as well as helping establish a good domain and IP reputation.

As your volume increases, you'll need to monitor your bounce rate to ensure it remains below 4%, and your spam rate below 0.08%. An increase in these rates would be a sign that your warm-up plan needs to be slowed down and an investigation into the root causes of the increases started.

Following these rules and metrics will establish a good domain reputation.

<Info>
  Each sender has different constraints and needs, so these numbers are meant as
  a baseline. Our [Support team](https://resend.com/help) can work with you on
  devising a plan adapted to your needs.
</Info>

# Existing domain

If you're already sending from an existing domain with established reputation and volumes, you can use the following guidelines to start sending with Resend.

| **Day** | **Messages per day** | **Messages per hour** |
| ------- | -------------------- | --------------------- |
| **1**   | Up to 1,000 emails   | 100 Maximum           |
| **2**   | Up to 2,500 emails   | 300 Maximum           |
| **3**   | Up to 5,000 emails   | 600 Maximum           |
| **4**   | Up to 5,000 emails   | 800 Maximum           |
| **5**   | Up to 7,500 emails   | 1,000 Maximum         |
| **6**   | Up to 7,500 emails   | 1,500 Maximum         |
| **7**   | Up to 10,000 emails  | 2,000 Maximum         |

# New domain

Before you start sending emails with a brand new domain, it's especially important to have a warm-up plan so you can maximize your deliverability right from the start.

| **Day** | **Messages per day** | **Messages per hour** |
| ------- | -------------------- | --------------------- |
| **1**   | Up to 150 emails     |                       |
| **2**   | Up to 250 emails     |                       |
| **3**   | Up to 400 emails     |                       |
| **4**   | Up to 700 emails     | 50 Maximum            |
| **5**   | Up to 1,000 emails   | 75 Maximum            |
| **6**   | Up to 1,500 emails   | 100 Maximum           |
| **7**   | Up to 2,000 emails   | 150 Maximum           |

# Warming up your Dedicated IP with Resend

In order for a Dedicated IP to be beneficial or useful, you first need to establish a certain sending volume and patterns. Once you've established this volume and these patterns, our [Support team](https://resend.com/help) can set it up for you.

We provide an automatic warm-up process so that you can simply focus on sending.

[Learn more about requesting a Dedicated IP](https://resend.com/docs/knowledge-base/how-do-dedicated-ips-work#how-to-request-a-dedicated-ip).

# What about third-party warm-up services?

We know email deliverability is important, and it can be tempting to use services promising quick fixes. However, using tools that artificially boost engagement can harm your long-term sender reputation. These services often rely on manipulating anti-spam filters, which can backfire as email providers like Gmail adjust their systems.

Instead, we recommend focusing on sustainable practices—such as sending relevant content, maintaining a clean list, and using proper authentication. These methods build trust with email providers and improve your deliverability over time.


# What attachment types are not supported?
Source: https://resend.com/docs/knowledge-base/what-attachment-types-are-not-supported

Learn which file attachment extensions you can't send.

You can **send** any file attachment types except for those in the following list.

|          |       |       |         |           |
| -------- | ----- | ----- | ------- | --------- |
| .adp     | .app  | .asp  | .bas    | .bat      |
| .cer     | .chm  | .cmd  | .com    | .cpl      |
| .crt     | .csh  | .der  | .exe    | .fxp      |
| .gadget  | .hlp  | .hta  | .inf    | .ins      |
| .isp     | .its  | .js   | .jse    | .ksh      |
| .lib     | .lnk  | .mad  | .maf    | .mag      |
| .mam     | .maq  | .mar  | .mas    | .mat      |
| .mau     | .mav  | .maw  | .mda    | .mdb      |
| .mde     | .mdt  | .mdw  | .mdz    | .msc      |
| .msh     | .msh1 | .msh2 | .mshxml | .msh1xml  |
| .msh2xml | .msi  | .msp  | .mst    | .ops      |
| .pcd     | .pif  | .plg  | .prf    | .prg      |
| .reg     | .scf  | .scr  | .sct    | .shb      |
| .shs     | .sys  | .ps1  | .ps1xml | .ps2      |
| .ps2xml  | .psc1 | .psc2 | .tmp    | .url      |
| .vb      | .vbe  | .vbs  | .vps    | .vsmacros |
| .vss     | .vst  | .vsw  | .vxd    | .ws       |
| .wsc     | .wsf  | .wsh  | .xnk    |           |

<Info>
  You can *receive* any file attachment types, including those listed above.
  These restrictions only apply to *sending* attachments.
</Info>


# What counts as email consent?
Source: https://resend.com/docs/knowledge-base/what-counts-as-email-consent

Learn what valid email permission looks like and why it matters.

Getting consent to send email isn’t just a legal requirement. It’s also essential for keeping your deliverability strong and your Resend account in good standing.

This guide explains what valid email permission looks like, why it matters, and how to set it up properly.

## Why consent matters

Many senders assume that if someone provides an email address, that automatically means it’s okay to email them. But that’s not always true and can often cause large-scale deliverability problems, especially for marketing or bulk messages.

Mailbox providers like Gmail and Outlook closely monitor how recipients react to your emails, paying special attention to whether people mark your emails as spam. High complaint rates or low overall engagement signal that your messages weren’t wanted, which can hurt your reputation and lead to filtering, blocking, or delivery issues.

## What *doesn’t* count as permission

These common methods are **not** considered valid:

* Including a clause in your Terms of Service that says users “agree to receive emails”
* Using a **pre-checked** box on your signup form for marketing messages
* Assuming someone is opted in unless they unsubscribe

These approaches violate email best practices and don’t meet legal standards [like GDPR](https://gdpr-info.eu/art-7-gdpr/).

## What *does* count as permission

Valid consent means the recipient **clearly and knowingly agreed** to receive the specific kind of email you're sending.

[According to GDPR](https://gdpr-info.eu/recitals/no-32/) (and general best practices), consent must be:

* **Freely given** – without pressure, bundling, or tricks
* **Specific** – clearly describes the type of messages the user will receive
* **Informed** – the user knows who you are and how you’ll use their data
* **Unambiguous** – requires an active opt-in (like checking a box)

In other words, recipients should be able to consent to each message type from a particular sender.

## What happens if you send without consent?

If you send to recipients who didn’t explicitly opt in, here’s what can happen:

1. Some of those people will **mark the message as spam**.
2. Mailbox providers may **block your mail or filter it to the spam folder**.
3. If your spam complaint or bounce rate remains high, [Resend may have to **pause or terminate your account**](https://resend.com/legal/acceptable-use) to protect our sending reputation.

And this applies *globally*, not just in the EU. Even if your emails are technically legal in your country, violating consent can lead to your mail being blocked or filtered to the spam folder.

## Best practice: Let people say “yes”

The easiest way to get consent is to **ask for it clearly and separately**. Add an unchecked checkbox to your signup form, like this:

>  Yes, I want to receive product updates and occasional marketing emails

**Follow these best practices:**

* Keep it **optional** and **unchecked** by default
* Make the wording clear and specific
* Place it outside of your Terms of Service
* Include a one-click unsubscribe link in every email

<img alt="Example of a consent checkbox and unsubscribe link" />

## Still have questions?

Following best practices helps everyone — your recipients, your deliverability, and the health of the email ecosystem. When you start with clear consent, your messages are the ones people are *glad* to receive.

If you’re new to permission-based sending, please reach out to [Support](https://resend.com/help) and we’ll help you make sure everything’s on track.


# What email addresses to use for testing?
Source: https://resend.com/docs/knowledge-base/what-email-addresses-to-use-for-testing

Learn what email addresses are safe to use for testing with Resend

## Safe email addresses for testing

When testing email functionality, it's important to use designated test addresses to avoid unintended consequences like deliverability issues or spam complaints.

Resend provides a set of safe email addresses specifically designed for testing, ensuring that you can simulate different email events without affecting your domain's reputation.

### Why not use @example.com or @test.com?

Many developers attempt to use domains like `@example.com` or `@test.com` for testing purposes. However, these domains are not designed for email traffic and often reject messages, leading to bounces.

A high bounce rate can negatively impact your sender reputation and affect future deliverability. To prevent this, Resend blocks such addresses and returns a `422 Unprocessable Entity` error if you attempt to send to them.

### List of addresses to use

To help you safely test email functionality, Resend provides the following test addresses, each designed to simulate a different delivery event:

| Address                 | Delivery event simulated |
| ----------------------- | ------------------------ |
| `delivered@resend.dev`  | Email being delivered    |
| `bounced@resend.dev`    | Email bouncing           |
| `complained@resend.dev` | Email marked as spam     |

Using these addresses in your tests allows you to validate email flows without risking real-world deliverability problems. For more help sending test emails, see our [testing documentation](/dashboard/emails/send-test-emails).

### Labeling support

All test email addresses support labeling, which enables you to send emails to the same test address in multiple ways. You can add a label after the `+` symbol to help track and differentiate between different test scenarios:

* `delivered+user1@resend.dev`
* `bounced+signup@resend.dev`
* `complained+newsletter@resend.dev`

This is particularly useful for testing different email flows, tracking webhook responses, and matching responses with the specific email address that triggered the event.

Whether you need to confirm that an email has been sent, track engagement events, or simulate a bounce scenario, these addresses provide a controlled and predictable way to test your email integration with Resend.


# What if an email says delivered but the recipient has not received it?
Source: https://resend.com/docs/knowledge-base/what-if-an-email-says-delivered-but-the-recipient-has-not-received-it

Learn the steps to take when an email is delivered, but the recipient does not receive it.

Some emails may be marked as `Delivered` but not reach the recipient's inbox due to various inbox sorting variables. This guide provides reasons for and advice on avoiding such issues.

## Why does this happen

When an email is sent, it is marked as `Delivered` once the recipient server accepts it with a `250 OK` response. However, the server can then direct the email to the inbox, queue it for later, route it to the spam folder, or even discard it. This is done by major inbox providers (e.g., Gmail, Yahoo, Outlook), as well as by IT departments and individual users who set up firewalls or filtering rules.

As a result, even though most legitimate emails should land in the intended inboxes, your message might end up in the spam/junk folder or, in rare cases, be deleted.

**Inbox Providers do not share any information on how the messages are later filtered.** Resend is only notified about the initial acceptance and marks the email as `Delivered`. Any subsequent events (e.g., open/click events, unsubscribes) require recipient engagement.

## How to avoid this

### If you are in contact with the user

The easiest way to solve this is by cooperating with the end user. If you have direct communication with the recipient, you can ask them to **check these places for your email**:

* Corporate spam filters or firewalls
* Personal inbox filtering
* Promotional, spam, or deleted folders
* Group inboxes or queues

If they find it, ask them to mark the email as `Not Spam` or add your domain to an allowlist.

### If you are not in contact with the user

Debugging without direct contact with the user is challenging. However, there are some optimizations that can **improve your chances of delivering to their inbox next time**:

* [Configure DMARC](/dashboard/domains/dmarc) to build trust with the inbox provider
* Warm up new domains slowly before sending large volumes
* Change all links in your email to use your own domain (matching your sender domain)
* Turn off open and click tracking
* Reduce the number of images in your email
* Improve wording to be succinct, clear, and avoid spammy words

We have an [extensive but practical deliverability guide](/knowledge-base/how-do-i-avoid-gmails-spam-folder) that covers these topics in more detail.


# What if my domain is not verifying?
Source: https://resend.com/docs/knowledge-base/what-if-my-domain-is-not-verifying

Learn what steps to take when your domain doesn't seem to verifying.

Verifying a domain involves a few steps:

1. Add your domain to Resend
2. Copy the required DNS records from Resend
3. Add these records to your DNS provider
4. Wait for verification to complete

When this process is completed correctly, your domain will often verify within 15 minutes of adding the DNS records. What should you do if your domain isn't verifying?

<Tip>
  If you are having any conflict issues with the `MX` records, [check out this
  guide](/knowledge-base/how-do-i-avoid-conflicting-with-my-mx-records).
</Tip>

## Common verification issues

When your domain doesn't verify as expected, it's typically due to DNS configuration issues. This guide will help you troubleshoot and resolve common verification problems.

### Incorrect DNS records

Usually when a domain doesn't verify, it's because the DNS records were not added correctly. Here's how to check:

1. Confirm that you've added all required records (DKIM, SPF, and MX)
2. Verify that the records are added at the correct location (the `send` subdomain, not the root domain)
3. Check that record values match exactly what Resend generated for you
4. Use a DNS lookup tool like [dns.email](https://dns.email) to verify your records are publicly visible

### DNS provider auto-appending domain names

Some DNS providers automatically append your domain name to record MX values, causing verification failures.

**Problem:**

Your MX record appears as:

`feedback-smtp.eu-west-1.amazonses.com.yourdomain.com`

Instead of:

`feedback-smtp.eu-west-1.amazonses.com`

**Solution:**

In your DNS provider, add a trailing period (dot) at the end of the record value:

`feedback-smtp.eu-west-1.amazonses.com.`

The trailing period tells your DNS provider that this is a fully qualified domain name that should not be modified.

<Tip>
  Note: The region your domain is added to is in this MX record. It may be
  `us-east-1`, `eu-west-1`, `ap-northeast-1`, or `sa-east-1` depending on the
  region.
</Tip>

### Nameserver conflicts

If your domain's DNS is managed in multiple places (e.g., Vercel, Cloudflare, your domain registrar), you might be adding records in the wrong location.

**How to check:** Run a nameserver lookup for your domain using a tool like [dns.email](https://dns.email) to see which provider actually controls your DNS. Add the Resend records at that provider, not elsewhere.

### DKIM record value mismatches

The DKIM record must match exactly what Resend generated. Common mistakes include:

1. Adding extra quotes or spaces
2. Truncating long values
3. Adding SPF information to the DKIM record
4. Not copying the entire value

Always copy and paste the exact value from Resend's domain configuration page.

### DNS Propagation

After adding or correcting your DNS records:

1. DNS changes can take up to 72 hours to propagate globally (though often much faster)
2. Use the "Restart verification" button in the Resend dashboard to trigger a fresh verification check
3. If verification still fails after 24 hours, use [dns.email](https://dns.email) to check if your records are visible publicly

## Need more help?

If you've followed all the steps above and your domain still isn't verifying, contact [Resend support](https://resend.com/help) with:

1. Your domain name
2. Screenshots of your DNS configuration

Our team will help identify any remaining issues preventing successful verification.

<AccordionGroup>
  <Accordion title="Check your records in the browser">
    Tools like [dns.email](https://dns.email) allow you to check your DNS records in the browser.

    Go to this URL and replace `yourdomain.com` with the domain you added in Resend.

    <img alt="Check domain records with dns.email" />

    You are looking to see the same values that you see in Resend.
  </Accordion>

  <Accordion title="Check your records in the terminal">
    Checking your DNS records in the terminal is just as easy. You can use the `nslookup` command and a record type flag to get the same information.

    Replace `yourdomain.com` with whatever you added as the domain in Resend:

    Check your DKIM `TXT` record:

    ```
    nslookup -type=TXT resend._domainkey.yourdomain.com
    ```

    Check your SPF `TXT` record:

    ```
    nslookup -type=TXT send.yourdomain.com
    ```

    Check your SPF `MX` record:

    ```
    nslookup -type=MX send.yourdomain.com
    ```

    <img alt="Check domain records with nslookup" />

    You are looking to see the same values that you see in Resend.
  </Accordion>
</AccordionGroup>


# What is Resend Pricing
Source: https://resend.com/docs/knowledge-base/what-is-resend-pricing

Learn more about Resend's pricing plans.

You can learn more about Resend's pricing at [resend.com/pricing](https://resend.com/pricing).


# What sending feature should I be using?
Source: https://resend.com/docs/knowledge-base/what-sending-feature-to-use

How to pick between our different sending features depending on your number of recipients and the nature of the message.

Resend allows you to send both **Transactional** and **Marketing** emails.

## What's the difference between Transactional and Marketing emails?

### What is a Transactional email?

A **Transactional email** is a message triggered by a user action or required for legal compliance. These emails are essential communications that users **cannot unsubscribe** from. Common examples include:

* Order confirmations
* Password reset emails
* Account notifications

Typically, transactional emails are **1-to-1** messages sent in response to a specific event.

### What is a Marketing email?

A **Marketing email** is any email that is not transactional. These can be **promotional**, **informative**, or **general communication** messages.

Marketing emails are regulated by laws like **CAN-SPAM** (US) and **CASL** (Canada), and **recipients must have the option to unsubscribe**.

Examples of marketing emails:

* Promotional offers and discounts
* Newsletters
* Product updates

Marketing emails can be **1-to-1** (e.g., abandoned cart reminders) or **1-to-many** (e.g., newsletters).

## Should I be sending a Transactional or a Marketing email?

While not exhaustive, here's a table listing different examples of emails and the most appropriate type for each example.

| Type of Message    | Type of Recipient | Transactional | Marketing |
| ------------------ | ----------------- | ------------- | --------- |
| Order confirmation | Single            | ✓             | ⨯         |
| Password reset     | Single            | ✓             | ⨯         |
| Abandoned cart     | Single            | ⨯             | ✓         |
| Newsletter         | Multiple          | ⨯             | ✓         |
| Promotional offer  | Multiple          | ⨯             | ✓         |

## How to send an email with Resend?

### How to send a Transactional email?

You can send a Transactional email using:

* Our [Send Email API](/api-reference/emails/send-email)
* Our [Batch Send API](/api-reference/emails/send-batch-emails) (send up to 100 transactional emails in one API call)

### How to send a Marketing email?

You can send Marketing emails using:

* [Resend no-code Editor](/dashboard/broadcasts/introduction) – a collaborative interface for designing emails
* [Broadcast API](/api-reference/broadcasts/create-broadcast) – for programmatic sending


# What's the difference between Opportunistic TLS vs Enforced TLS?
Source: https://resend.com/docs/knowledge-base/whats-the-difference-between-opportunistic-tls-vs-enforced-tls

Understand the different TLS configurations available.

Resend supports TLS 1.2, TLS 1.1 and TLS 1.0 for TLS connections.

There are two types of TLS configurations available:

* Opportunistic TLS
* Enforced TLS

## What is Opportunistic TLS?

Opportunistic TLS means that Resend always attempts to make a secure connection to the receiving mail server.

If the receiving server does not support TLS, the fallback is sending the message unencrypted.

## What is Enforced TLS?

Enforced TLS means that the email communication must use TLS no matter what.

If the receiving server does not support TLS, the email will not be sent.

## Is Enforced TLS better than Opportunistic TLS?

One strategy is not necessarily better than the other.

The decision is less about one option being safe and the other being unsafe, and more about one option being safe and the other being safer.

When you have Enforced TLS enabled, you might see an increase in bounce rates because some outdated mail servers do not support TLS.

So it's important to understand the different use cases for each configuration. If you're sending sensitive information like authentication emails, you might want to use Enforced TLS. If you're sending marketing emails, you might want to use Opportunistic TLS.

In simple terms, with Opportunistic TLS, delivery is more important than security. On the other hand, with Enforced TLS, security is more important than delivery.


# Why are my emails landing on the Suppression List?
Source: https://resend.com/docs/knowledge-base/why-are-my-emails-landing-on-the-suppression-list

Learn why your emails land on the Suppression List and how to remove them.

When sending to an email address results in a hard bounce, Resend places this address on the Suppression List. Emails placed on the list cannot be sent to until they are removed.

<Info>
  We place emails on the Suppression List to protect domain reputation, both
  yours and ours. Sending an email to a known hard bounce recipient can damage
  domain reputation and affect email deliverability.
</Info>

## Reasons emails are placed on the Suppression List

Here are some possible reasons an email address is placed on the Suppression List:

* The recipient's email address **contains a typo**.
* The recipient's email address **doesn't exist**.
* The recipient's email server has **permanently blocked delivery**.
* The recipient has marked the delivery as spam.

## View email bounce details

You can view the reason an email bounced on the [Emails](https://resend.com/emails) page:

1. Open the [Emails](https://resend.com/emails) page and search for the recipient's email address in question.
2. Click on the email to view its details.
3. Hover over the `Bounced` status indicator to see a summary of the bounce reason.

<img alt="Email Bounce Notification" />

For more technical details and suggested next steps, click the **See details** button. The drawer will open on the right side of your screen with the bounce type, subtype, and suggestions on how to proceed.

## What happens if you try sending to a recipient on the suppression list?

Whenever you send an email with Resend, we check if the recipient is on the suppression list. If they are, we'll [suppress](/dashboard/emails/email-suppressions.mdx) the delivery to prevent damaging your sender reputation and our infrastructure.

## Removing an email address from the Suppression List

You may be able to send a message to the same recipient in the future if the issue that caused the message to bounce is resolved and the email address is removed from the Suppression List.

<Warning>
  Remember, if you do not address the issue that caused the email to bounce, the
  email address will return to the Suppression List the next time you attempt to
  send to it.
</Warning>

To remove your recipient from the Suppression List, click on the email in the [emails dashboard](https://resend.com/emails), and click **Remove from suppression list**.

<img alt="Email Bounced button" />


# Why are my open rates not accurate?
Source: https://resend.com/docs/knowledge-base/why-are-my-open-rates-not-accurate

Learn why your open rate statistics are not accurate and what you can do about it.

## How are open rates tracked?

A 1x1 pixel transparent GIF image is inserted in each email and includes a unique reference. When the image is downloaded, an open event is triggered.

## Why are my open rates not accurate?

Open tracking is generally not accurate because each inbox handles incoming email differently.

**Clipped messages in Gmail** happen when you send a message over 102KB. A message over this size won’t be counted as an open unless the recipient views the entire message. Resend’s Deliverability Insights on the email will note if a message exceeds this threshold.

**Some inboxes do not download images by default** or block/cache assets with a corporate firewall. This approach can prevent the open event from being tracked.

**Other inboxes open the email prior to delivering** in order to scan for malware or to [protect user privacy](https://www.apple.com/newsroom/2021/06/apple-advances-its-privacy-leadership-with-ios-15-ipados-15-macos-monterey-and-watchos-8/). This approach can trigger an open event without the recipient reading your email.

**Emails sent with only a plain text version** will not include open tracking at all. Since open tracking relies on a 1x1 pixel image, plain text emails cannot trigger open events. Only emails with an HTML version can be tracked for opens.

Because of this, open tracking is **not a statistically accurate way** of detecting if your users are engaging with your content.

## Does open tracking impact inbox placement?

Though open tracking should not impact if your email is delivered, it most likely will impact your inbox placement. Trackers are generally **used by marketers and even spammers**. Because of this, inbox providers will often use open tracking as a signal that your email is promotional, or even spam, and categorize accordingly.

**We suggest disabling open rates for transactional email**, to maximize inbox placement.

## What's the alternative?

Instead of relying on open rates, there are a few other ways to still understand your sending.

1. **Track Clicks:** Monitoring the link clicks is an even more granular way to know how a recipient engaged with your email. By knowing if they clicked, you also know that they read parts of your email and took action.
2. **Track Outside the Inbox:** Often emails are sent as a means to an end. Maybe it's to increase page visits of an announcement or convert free users to paid. Tracking your sending by metrics outside of the inbox can be a great way to understand the true impact of your sending.


# Official SDKs
Source: https://resend.com/docs/sdks

Open source client libraries for your favorite platforms.

## Official SDKs

<CardGroup>
  <Card title="Node.js" icon="github" href="https://github.com/resend/resend-node">
    github.com/resend/resend-node
  </Card>

  <Card title="PHP" icon="github" href="https://github.com/resend/resend-php">
    github.com/resend/resend-php
  </Card>

  <Card title="Laravel" icon="github" href="https://github.com/resend/resend-laravel">
    github.com/resend/resend-laravel
  </Card>

  <Card title="Python" icon="github" href="https://github.com/resend/resend-python">
    github.com/resend/resend-python
  </Card>

  <Card title="Ruby" icon="github" href="https://github.com/resend/resend-ruby">
    github.com/resend/resend-ruby
  </Card>

  <Card title="Go" icon="github" href="https://github.com/resend/resend-go">
    github.com/resend/resend-go
  </Card>

  <Card title="Java" icon="github" href="https://github.com/resend/resend-java">
    github.com/resend/resend-java
  </Card>

  <Card title="Rust" icon="github" href="https://github.com/resend/resend-rust">
    github.com/resend/resend-rust
  </Card>

  <Card title=".NET" icon="github" href="https://github.com/resend/resend-dotnet">
    github.com/resend/resend-dotnet
  </Card>
</CardGroup>

## Community SDKs

<CardGroup>
  <Card title="Elixir" icon="github" href="https://github.com/elixir-saas/resend-elixir">
    github.com/elixir-saas/resend-elixir
  </Card>

  <Card title="NestJS" icon="github" href="https://github.com/jiangtaste/nestjs-resend">
    github.com/jiangtaste/nestjs-resend
  </Card>

  <Card title="Dart" icon="github" href="https://github.com/coderaveHQ/dart_resend">
    github.com/coderaveHQ/dart\_resend
  </Card>
</CardGroup>

## OpenAPI

<CardGroup>
  <Card title="OpenAPI" icon="github" href="https://github.com/resend/resend-openapi">
    github.com/resend/resend-openapi
  </Card>
</CardGroup>


# Security
Source: https://resend.com/docs/security

An overview of Resend security features and practices.

## Governance

Resend establishes policies and controls, monitors compliance with those controls, and proves the security and compliance to third-party auditors.

Our policies are based on the following **foundational principles**:

<CardGroup>
  <Card title="Least Privilege" icon="square-1">
    Access should be limited to only those with a legitimate business needs,
    based on the principle of least privilege.
  </Card>

  <Card title="Consistency" icon="square-2">
    Security controls should be applied consistently across all areas of the
    enterprise.
  </Card>

  <Card title="Defense in Depth" icon="square-3">
    Security controls should be implemented and layered according to the
    principle of defense-in-depth.
  </Card>

  <Card title="Continuous Improvement" icon="square-4">
    The implementation of controls should be iterative, continuously improving
    effectiveness and decreasing friction.
  </Card>
</CardGroup>

### Compliance Standards

<AccordionGroup>
  <Accordion title="SOC 2 Type II" icon="hourglass-clock">
    Resend is SOC 2 Type II compliant. The audit was completed by Vanta & Advantage Partners.
    You can download a copy of the report on the [Documents](https://resend.com/settings/documents) page.
  </Accordion>

  <Accordion title="GDPR" icon="hourglass-clock">
    Resend is GDPR compliant. You can learn more about our [GDPR compliance](https://resend.com/security/gdpr) or view our [DPA](https://resend.com/legal/dpa).
  </Accordion>
</AccordionGroup>

## Data Protection

<CardGroup>
  <Card title="Data at rest" icon="server">
    All datastores are encrypted at rest. Sensitive collections and tables also
    use row-level encryption.
  </Card>

  <Card title="Data in transit" icon="network-wired">
    Resend uses TLS 1.3 or higher everywhere data is transmitted over
    potentially insecure networks.
  </Card>

  <Card title="Data backup" icon="database">
    Resend backs-up all production data using a point-in-time approach. Backups
    are persisted for 30 days, and are globally replicated for resiliency
    against regional disasters.
  </Card>
</CardGroup>

## Product Security

### Penetration testing

Resend engages with third-party firms to conduct penetration testing at least annually.

All areas of the Resend product and cloud infrastructure are in-scope for these assessments, and source code is fully available to the testers in order to maximize the effectiveness and coverage.

You can download the latest penetration test report on the [Documents](https://resend.com/settings/documents) page.

### Vulnerability scanning

Resend uses multiple vulnerability monitoring techniques including code-level scanning, dependency scanning, and security reviews to identify and remediate vulnerabilities.

Vulnerabilities are prioritized based on severity and risk, and are remediated according to the following schedule:

* Critical: 15 Days
* High: 30 Days
* Medium: 90 Day
* Low: 180 Days
* Informational: As needed

## Enterprise Security

<CardGroup>
  <Card title="Endpoint protection" icon="computer">
    All company devices are equipped with anti-malware protection. Endpoint security alerts are monitored with 24/7/365 coverage. We use MDM software to enforce secure configuration of endpoints, such as disk encryption, screen lock configuration, and software updates.
  </Card>

  <Card title="Security education" icon="graduation-cap">
    Resend provides comprehensive security training to all employees upon onboarding and annually.

    Resend's conducts threat briefings with employees to inform them of important security and safety-related updates that require special attention or action.
  </Card>

  <Card title="Identity and access management" icon="id-badge">
    Resend employees are granted access to applications based on their role, and automatically deprovisioned upon termination of their employment. Further access must be approved according to the policies set for each application.

    Multi-factor authentication is required for all employees to access company applications.
  </Card>
</CardGroup>

## Responsible Disclosure

To report a vulnerability, please check the guidelines on the [Responsible Disclosure](https://resend.com/security/responsible-disclosure) page.


# Send emails with Astro
Source: https://resend.com/docs/send-with-astro

Learn how to send your first email using Astro, Resend, and Node.js.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

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

<YouTube />

## 1. Install

Install Resend for Node.js.

<CodeGroup>
  ```bash npm theme={null}
  npm install resend
  ```

  ```bash yarn theme={null}
  yarn add resend
  ```

  ```bash pnpm theme={null}
  pnpm add resend
  ```

  ```bash bun theme={null}
  bun add resend
  ```
</CodeGroup>

## 2. Install an SSR adapter

Because Astro builds a static site by default, [install an SSR adapter](https://docs.astro.build/en/guides/server-side-rendering/) to enable on-demand rendering of routes.

## 3. Add your API key

[Create an API key](https://resend.com/api-keys) in Resend and add it to your `.env` file to keep your API key secret.

```ini .env theme={null}
RESEND_API_KEY="re_xxxxxxxxx"
```

## 4. Send email using HTML

Create an [Astro Action](https://docs.astro.build/en/guides/actions/) under `actions/index.ts`.

The easiest way to send an email is with the `html` parameter.

<CodeGroup>
  ```ts src/actions/index.ts theme={null}
  import { ActionError, defineAction } from 'astro:actions';
  import { Resend } from 'resend';

  const resend = new Resend(import.meta.env.RESEND_API_KEY);

  export const server = {
    send: defineAction({
      accept: 'form',
      handler: async () => {
        const { data, error } = await resend.emails.send({
          from: 'Acme <onboarding@resend.dev>',
          to: ['delivered@resend.dev'],
          subject: 'Hello world',
          html: '<strong>It works!</strong>',
        });

        if (error) {
          throw new ActionError({
            code: 'BAD_REQUEST',
            message: error.message,
          });
        }

        return data;
      },
    }),
  };
  ```
</CodeGroup>

Call the `send` action from any frontmatter route, script, or component.

## 5. Try it yourself

<Card title="Astro Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-astro-example">
  See the full source code.
</Card>


# Send emails using Auth0 with SMTP
Source: https://resend.com/docs/send-with-auth0-smtp

Learn how to integrate Auth0 with Resend SMTP.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Get the Resend SMTP credentials

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465` or `587` (see [port options](#port-options) below)
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

### Port options

Resend supports multiple ports for different security configurations:

| Type     | Port                | Security                                                                  |
| -------- | ------------------- | ------------------------------------------------------------------------- |
| SMTPS    | `465`, `2465`       | Implicit SSL/TLS (Immediately connects via SSL/TLS)                       |
| STARTTLS | `25`, `587`, `2587` | Explicit SSL/TLS (First connects via plaintext, then upgrades to SSL/TLS) |

For Auth0, we recommend using port `465` (SMTPS) or `587` (STARTTLS).

## 2. Integrate with Auth0 SMTP

After logging into your [Auth0](https://auth0.com/) dashboard, you'll need to enable the SMTP integration.

1. From your Auth0 dashboard, go to [Branding > Email Provider](https://manage.auth0.com/#/templates/provider).
2. Enable the **Use my own email provider** toggle.
3. Select **SMTP Provider**.
4. Enter a **From** email address, and then enter the Resend SMTP server's **Host**, **Port**, **Username**, and your API key as the **Password**.

<img alt="Auth0 SMTP - Email Provider Settings" />

## 3. Send a test email

Once you have configured the SMTP settings, click **Save**. Next send a test email using the **Send Test Email** button. If everything is configured correctly, you will receive a confirmation email. If you did not receive an email, check your [Auth0 Logs](https://manage.auth0.com/#/logs).


# Send emails with AWS Lambda
Source: https://resend.com/docs/send-with-aws-lambda

Learn how to send your first email using AWS Lambda.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Create a AWS Lambda function

Go to [aws.amazon.com](https://aws.amazon.com) and create a new Lambda function using the Node.js 20.x or later runtime.

<img alt="AWS Lambda - New Function" />

## 2. Edit the handler function

Paste the following code into the browser editor:

```js index.mjs theme={null}
const RESEND_API_KEY = 're_xxxxxxxxx';

export const handler = async (event) => {
  const res = await fetch('https://api.resend.com/emails', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${RESEND_API_KEY}`,
    },
    body: JSON.stringify({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'hello world',
      html: '<strong>it works!</strong>',
    }),
  });

  if (res.ok) {
    const data = await res.json();

    return {
      statusCode: 200,
      body: data,
    };
  }
};
```

## 3. Deploy and send email

Click on `Deploy` and then `Test` at the top of the screen.

<img alt="AWS Lambda - Edit Function" />

## 4. Try it yourself

<Card title="AWS Lambda Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-aws-lambda-example">
  See the full source code.
</Card>


# Send emails with Axum
Source: https://resend.com/docs/send-with-axum

Send your first email using Axum and the Resend Rust SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Rust SDK and the [Tokio](https://tokio.rs) runtime.

```bash theme={null}
cargo add resend-rs
cargo add tokio -F macros,rt-multi-thread
```

## 2. Send an Email

```rust theme={null}
use std::sync::Arc;

use axum::{extract::State, http::StatusCode, routing::get, Router};
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

// Cloning the Resend client is fine and cheap as the internal HTTP client is
// not cloned.
#[derive(Clone)]
struct AppState {
  resend: Resend,
}

#[tokio::main]
async fn main() {
  let shared_state = Arc::new(AppState {
    resend: Resend::new("re_xxxxxxxxx"),
  });

  // build our application with a single route
  let app = Router::new()
    .route("/", get(endpoint))
    // provide the state so the router can access it
    .with_state(shared_state);

  // run our app with hyper, listening globally on port 3000
  let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
  axum::serve(listener, app).await.unwrap();
}

async fn endpoint(State(state): State<Arc<AppState>>) -> Result<String, StatusCode> {
  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Hello World";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<strong>It works!</strong>");

  // access the state via the `State` extractor and handle the error
  match state.resend.emails.send(email).await {
    Ok(email) => Ok(email.id.to_string()),
    Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
  }
}
```

Opening your browser at `http://localhost:3000` (or running `curl localhost:3000`) should send an
email and return you its id!

## 3. Try it yourself!

<Card title="Axum Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-axum-example">
  See the full source code.
</Card>


# Send emails with Bun
Source: https://resend.com/docs/send-with-bun

Learn how to send your first email using Bun and the Resend Node.js SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Node.js SDK.

```bash theme={null}
bun install resend
```

## 2. Create an email template

Start by creating your email template on `email-template.tsx`.

```tsx email-template.tsx theme={null}
import * as React from 'react';

interface EmailTemplateProps {
  firstName: string;
}

export const EmailTemplate = ({ firstName }: EmailTemplateProps) => (
  <div>
    <h1>Welcome, {firstName}!</h1>
  </div>
);
```

## 3. Send email using React

Create a new file `index.tsx` and send your first email.

```tsx index.tsx theme={null}
import { Resend } from 'resend';
import { EmailTemplate } from './email-template';

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

const server = Bun.serve({
  port: 3000,
  async fetch() {
    const data = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello World',
      react: EmailTemplate({ firstName: 'Vitor' }),
    });

    return new Response(JSON.stringify(data));
  },
});

console.log(`Listening on http://localhost:${server.port} ...`);
```

Start the local server by running `bun index.tsx` and navigate to `http://localhost:3000`.

## 3. Try it yourself

<Card title="Bun Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-bun-example">
  See the full source code.
</Card>


# Send emails with Cloudflare Workers
Source: https://resend.com/docs/send-with-cloudflare-workers

Learn how to send your first email using Cloudflare Workers.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)
* Have a Cloudflare worker with a bundling setup
  * Recommended to be bootstrapped with `npm create cloudflare`

## 1. Install

Get the Resend Node.js SDK.

<CodeGroup>
  ```bash npm theme={null}
  npm install resend
  ```

  ```bash yarn theme={null}
  yarn add resend
  ```

  ```bash pnpm theme={null}
  pnpm add resend
  ```

  ```bash bun theme={null}
  bun add resend
  ```
</CodeGroup>

## 2. Create an email template

Start by creating your email template on `src/emails/email-template.tsx`:

```tsx src/emails/email-template.tsx theme={null}
import * as React from 'react';

interface EmailTemplateProps {
  firstName: string;
}

export function EmailTemplate({ firstName }: EmailTemplateProps) {
  return (
    <div>
      <h1>Welcome, {firstName}!</h1>
    </div>
  );
}

export default EmailTemplate;
```

## 3. Send the email using React and the SDK

Change the file extension of the worker's main file to `tsx` and modify your configurations.

After that, you can send your email using the `react` parameter:

```tsx src/index.tsx theme={null}
import { Resend } from 'resend';
import { EmailTemplate } from './emails/email-template';

export default {
  async fetch(request, env, context): Promise<Response> {
    const resend = new Resend('re_xxxxxxxxx');

    const data = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'hello world',
      react: <EmailTemplate firstName="John" />,
    });

    return Response.json(data);
  },
} satisfies ExportedHandler<Env, ExecutionContext>;
```

## 4. Deploy and send email

Run `wrangler deploy` and wait for it to finish. Once it's done, it will
give you a URL to try out, like `https://my-worker.your_name.workers.dev`,
that you can open and verify that your email has been sent.

## 5. Try it yourself

<Card title="Cloudflare Workers Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-cloudflare-workers-example">
  See the full source code.
</Card>


# Send emails using Customer.io with SMTP
Source: https://resend.com/docs/send-with-customer-io-smtp

Learn how to integrate Customer.io with Resend SMTP.

### Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Get the Resend SMTP credentials

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

## 2. Integrate with Customer.io SMTP

After logging into your [Customer.io](https://customer.io) account, you'll need to enable the SMTP integration.

1. Go to **Settings** > **Workspace Settings**.

<img alt="Customer.io SMTP - Workspace Settings" />

2. Go to the Messaging tab and select **Email**.

<img alt="Customer.io SMTP - Email" />

3. Select the **Custom SMTP** tab and click **Add Custom SMTP Server**.

<img alt="Customer.io SMTP - Add Custom SMTP Server" />

4. Select **Other SMTP** and click **Continue to set up**.

<img alt="Customer.io SMTP - Other SMTP" />

5. Copy-and-paste the SMTP credentials from Resend to Customer.io.

<img alt="Customer.io SMTP integration" />


# Send emails with Deno Deploy
Source: https://resend.com/docs/send-with-deno-deploy

Learn how to send your first email using Deno Deploy.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Create a Deno Deploy project

Go to [dash.deno.com/projects](https://dash.deno.com/projects) and create a new playground project.

<img alt="Deno Deploy - New Project" />

## 2. Edit the handler function

Paste the following code into the browser editor:

```ts main.ts theme={null}
import { Resend } from 'npm:resend';

const resend = new Resend('re_123456789');

Deno.serve(async () => {
  try {
    const response = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello World',
      html: '<strong>It works!</strong>',
    });

    return new Response(JSON.stringify(response), {
      status: response.error ? 500 : 200,
      headers: {
        'Content-Type': 'application/json',
      },
    });
  } catch (error) {
    console.error(error);
    return new Response(null, {
      status: 500,
    });
  }
});
```

## 3. Deploy and send email

Click on `Save & Deploy` at the top of the screen.

<img alt="Deno Deploy - Playground" />

## 4. Try it yourself

<Card title="Deno Deploy Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-deno-deploy-example">
  See the full source code.
</Card>


# Send emails with Django
Source: https://resend.com/docs/send-with-django

Learn how to send your first email using Django and the Resend Python SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the [django-anymail](https://anymail.dev/en/stable/esps/resend/) package with Resend support.

<CodeGroup>
  ```bash Pip theme={null}
  pip install django-anymail[resend]
  ```
</CodeGroup>

## 2. Configure

Add Anymail to your Django settings.

```py settings.py theme={null}
import os

INSTALLED_APPS = [
    # ...
    "anymail",
]

EMAIL_BACKEND = "anymail.backends.resend.EmailBackend"
ANYMAIL = {
    "RESEND_API_KEY": os.environ.get("RESEND_API_KEY"),
}
DEFAULT_FROM_EMAIL = "onboarding@resend.dev"
```

## 3. Send email using HTML

The easiest way to send an email is by using the `html_message` parameter.

```py views.py theme={null}
from django.core.mail import send_mail
from django.http import JsonResponse

def send_email(request):
    send_mail(
        subject="Hello from Django + Resend",
        message="This is a plain text message.",
        from_email="Acme <onboarding@resend.dev>",
        recipient_list=["delivered@resend.dev"],
        html_message="<strong>it works!</strong>",
    )

    return JsonResponse({"message": "Email sent successfully"})
```

## 4. Send email using a template

For more complex emails, you can use Django's template system.

First, create an HTML template at `templates/emails/welcome.html`:

```html templates/emails/welcome.html theme={null}
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title>Welcome Email</title>
  </head>
  <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #333;">
    <h1>Welcome, {{ user_name }}!</h1>
    <p>Thank you for joining our service.</p>
    <p>Your account email: <strong>{{ user_email }}</strong></p>
    <p>
      <a
        href="{{ dashboard_url }}"
        style="background-color: #007bff; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px;"
      >
        Go to Dashboard
      </a>
    </p>
  </body>
</html>
```

Then render and send the template:

```py views.py theme={null}
from django.core.mail import EmailMessage
from django.http import JsonResponse
from django.template.loader import render_to_string

def send_template_email(request):
    html_content = render_to_string('emails/welcome.html', {
        'user_name': 'Django Developer',
        'user_email': 'delivered@resend.dev',
        'dashboard_url': 'https://example.com/dashboard',
    })

    message = EmailMessage(
        subject="Welcome to Our Service!",
        body=html_content,
        from_email="Acme <onboarding@resend.dev>",
        to=["delivered@resend.dev"],
    )
    message.content_subtype = "html"
    message.send()

    return JsonResponse({"message": "Email sent successfully"})
```

## 5. Try it yourself

<Card title="Django Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-django-example">
  See the full source code.
</Card>


# Send emails using Django with SMTP
Source: https://resend.com/docs/send-with-django-smtp

Learn how to integrate Django with Resend SMTP.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)
* Install `virtualenv` by running `pip install virtualenv`

## 1. Setup your environment

Create and activate your new virtualenv.

```bash theme={null}
virtualenv venv
source venv/bin/activate
```

Install dependencies.

```sh theme={null}
pip install -r requirements.txt
```

Set your `RESEND_API_KEY` environment variable by running.

```sh theme={null}
export RESEND_API_KEY="re_xxxxxxxxx"
```

## 2. Send email using Django's SMTP EmailMessage

Set the necessary attributes in your `settings.py` file.

```py theme={null}
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
RESEND_SMTP_PORT = 587
RESEND_SMTP_USERNAME = 'resend'
RESEND_SMTP_HOST = 'smtp.resend.com'
```

Use Django's `get_connection` and `EmailMessage`

```py theme={null}
import os
from django.conf import settings
from django.http import JsonResponse
from django.core.mail import EmailMessage, get_connection

# Sample Django view
def index(request):

    subject = "Hello from Django SMTP"
    recipient_list = ["delivered@resend.dev"]
    from_email = "onboarding@resend.dev"
    message = "<strong>it works!</strong>"

    with get_connection(
        host=settings.RESEND_SMTP_HOST,
        port=settings.RESEND_SMTP_PORT,
        username=settings.RESEND_SMTP_USERNAME,
        password=os.environ["RESEND_API_KEY"],
        use_tls=True,
        ) as connection:
            r = EmailMessage(
                  subject=subject,
                  body=message,
                  to=recipient_list,
                  from_email=from_email,
                  connection=connection).send()
    return JsonResponse({"status": "ok"})
```

## 3. Try it yourself

<Card title="Django SMTP Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-django-smtp-example">
  See the full source code.
</Card>


# Send emails with .NET
Source: https://resend.com/docs/send-with-dotnet

Learn how to send your first email using the Resend .NET SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

Prefer watching a video? Check out our video walkthrough below.

<YouTube />

## 1. Install

<CodeGroup>
  ```bash dotnet CLI theme={null}
  dotnet add package Resend
  ```

  ```bash Visual Studio (Package Manager Console) theme={null}
  PM> Install-Package Resend
  ```
</CodeGroup>

## 2. Send emails using HTML

In the startup of your application, configure the DI container as follows:

```csharp theme={null}
using Resend;

builder.Services.AddOptions();
builder.Services.AddHttpClient<ResendClient>();
builder.Services.Configure<ResendClientOptions>( o =>
{
    o.ApiToken = Environment.GetEnvironmentVariable( "RESEND_APITOKEN" )!;
} );
builder.Services.AddTransient<IResend, ResendClient>();
```

Send an email using the injected `IResend` instance:

```csharp theme={null}
using Resend;

public class FeatureImplementation
{
    private readonly IResend _resend;


    public FeatureImplementation( IResend resend )
    {
        _resend = resend;
    }


    public Task Execute()
    {
        var message = new EmailMessage();
        message.From = "Acme <onboarding@resend.dev>";
        message.To.Add( "delivered@resend.dev" );
        message.Subject = "hello world";
        message.HtmlBody = "<strong>it works!</strong>";

        await _resend.EmailSendAsync( message );
    }
}
```

## 3. Try it yourself

<CardGroup>
  <Card title="ASP.NET Controller API" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-dotnet/tree/master/examples/WebControllerApi">
    See the full source code.
  </Card>

  <Card title="" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-dotnet/tree/master/examples">
    List of .NET examples (API, Web, HTML rendering, Async sending).
  </Card>
</CardGroup>


# Send emails with Elixir
Source: https://resend.com/docs/send-with-elixir

Learn how to send your first email using the Resend Elixir SDK.

<Info>
  This guides utilizes an [open source
  library](https://github.com/elixir-saas/resend-elixir) contributed by a
  community member. It's not developed, maintained, or supported by Resend
  directly.
</Info>

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Install by adding `resend` to your list of dependencies in `mix.exs`:

<CodeGroup>
  ```elixir mix.exs theme={null}
  def deps do
    [
      {:resend, "~> 0.4.0"}
    ]
  end
  ```
</CodeGroup>

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```elixir send.exs theme={null}
client = Resend.client(api_key: System.get_env("RESEND_API_KEY"))

Resend.Emails.send(client, %{
  from: "Acme <onboarding@resend.dev>",
  to: ["delivered@resend.dev"],
  subject: "hello world",
  html: "<strong>it works!</strong>"
})
```

## 3. Try it yourself

<Card title="Elixir Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-elixir-example">
  See the full source code.
</Card>


# Send emails with Express
Source: https://resend.com/docs/send-with-express

Learn how to send your first email using Express and the Resend Node.js SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Node.js SDK.

<CodeGroup>
  ```bash npm theme={null}
  npm install resend
  ```

  ```bash yarn theme={null}
  yarn add resend
  ```

  ```bash pnpm theme={null}
  pnpm add resend
  ```

  ```bash bun theme={null}
  bun add resend
  ```
</CodeGroup>

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```js server.ts theme={null}
import express, { Request, Response } from "express";
import { Resend } from "resend";

const app = express();
const resend = new Resend("re_xxxxxxxxx");

app.get("/", async (req: Request, res: Response) => {
  const { data, error } = await resend.emails.send({
    from: "Acme <onboarding@resend.dev>",
    to: ["delivered@resend.dev"],
    subject: "hello world",
    html: "<strong>it works!</strong>",
  });

  if (error) {
    return res.status(400).json({ error });
  }

  res.status(200).json({ data });
});

app.listen(3000, () => {
  console.log("Listening on http://localhost:3000");
});
```

## 3. Try it yourself

<Card title="Express Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-express-example">
  See the full source code.
</Card>


# Send emails with FastAPI
Source: https://resend.com/docs/send-with-fastapi

Learn how to send your first email using FastAPI and the Resend Python SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Python SDK.

<CodeGroup>
  ```bash Pip theme={null}
  pip install resend
  ```
</CodeGroup>

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```py main.py theme={null}
import os
from typing import Dict
from fastapi import FastAPI
import resend

resend.api_key = os.environ["RESEND_API_KEY"]

app = FastAPI()

@app.post("/")
def send_mail() -> Dict:
    params: resend.Emails.SendParams = {
        "from": "Acme <onboarding@resend.dev>",
        "to": ["delivered@resend.dev"],
        "subject": "hello world",
        "html": "<strong>it works!</strong>",
    }
    email: resend.Emails.SendResponse = resend.Emails.send(params)
    return email
```

## 3. Try it yourself

<Card title="FastAPI Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-fastapi-example">
  See the full source code.
</Card>


# Send emails with Flask
Source: https://resend.com/docs/send-with-flask

Learn how to send your first email using Flask and the Resend Python SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Python SDK.

<CodeGroup>
  ```bash Pip theme={null}
  pip install resend
  ```
</CodeGroup>

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```py index.py theme={null}
import resend
import os
from flask import Flask, jsonify

resend.api_key = os.environ["RESEND_API_KEY"]

app = Flask(__name__)


@app.route("/")
def index():
    params: resend.Emails.SendParams = {
        "from": "Acme <onboarding@resend.dev>",
        "to": ["delivered@resend.dev"],
        "subject": "hello world",
        "html": "<strong>it works!</strong>",
    }

    r = resend.Emails.send(params)
    return jsonify(r)


if __name__ == "__main__":
    app.run()
```

## 3. Try it yourself

<Card title="Flask Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-flask-example">
  See the full source code.
</Card>


# Send emails with Go
Source: https://resend.com/docs/send-with-go

Learn how to send your first email using the Resend Go SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Go SDK.

<CodeGroup>
  ```bash bash theme={null}
  go get github.com/resend/resend-go/v3
  ```
</CodeGroup>

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```Go main.go theme={null}
package main

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

func main() {
    apiKey := "re_xxxxxxxxx"

    client := resend.NewClient(apiKey)

    params := &resend.SendEmailRequest{
        From:    "Acme <onboarding@resend.dev>",
        To:      []string{"delivered@resend.dev"},
        Html:    "<strong>hello world</strong>",
        Subject: "Hello from Golang",
        Cc:      []string{"cc@example.com"},
        Bcc:     []string{"bcc@example.com"},
        ReplyTo: "replyto@example.com",
    }

    sent, err := client.Emails.Send(params)
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    fmt.Println(sent.Id)
}
```

## 3. Try it yourself

<Card title="Golang Examples" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-go-example">
  See the full source code.
</Card>


# Send emails with Hono
Source: https://resend.com/docs/send-with-hono

Learn how to send your first email using Hono and the Resend Node.js SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Node.js SDK.

<CodeGroup>
  ```bash npm theme={null}
  npm install resend
  ```

  ```bash yarn theme={null}
  yarn add resend
  ```

  ```bash pnpm theme={null}
  pnpm add resend
  ```

  ```bash bun theme={null}
  bun add resend
  ```
</CodeGroup>

## 2. Create an email template

Start by creating your email template on `emails/email-template.tsx`.

```tsx emails/email-template.tsx theme={null}
import * as React from 'react';

interface EmailTemplateProps {
  firstName: string;
}

export function EmailTemplate({ firstName }: EmailTemplateProps) {
  return (
    <div>
      <h1>Welcome, {firstName}!</h1>
    </div>
  );
}
```

To use JSX/TSX with Hono, we need to modify the `tsconfig.json`.

```json tsconfig.json theme={null}
{
  "compilerOptions": {
    "jsx": "react-jsx",
    "jsxImportSource": "react"
  }
}
```

## 3. Send email using React

Create a new file `index.tsx` and send your first email.

```ts index.tsx theme={null}
import { Hono } from 'hono';
import { Resend } from 'resend';
import { EmailTemplate } from './emails/email-template';

const app = new Hono();
const resend = new Resend('re_xxxxxxxxx');

app.get('/', async (c) => {
  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    react: <EmailTemplate firstName="John" />,
  });

  if (error) {
    return c.json(error, 400);
  }

  return c.json(data);
});

export default app;
```

## 4. Try it yourself

<Card title="Hono Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-hono-example">
  See the full source code.
</Card>


# Send emails with Java
Source: https://resend.com/docs/send-with-java

Learn how to send your first email using the Resend Java SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

<CodeGroup>
  ```bash Gradle theme={null}
  implementation 'com.resend:resend-java:+'
  ```

  ```xml Maven theme={null}
  <dependency>
      <groupId>com.resend</groupId>
      <artifactId>resend-java</artifactId>
      <version>LATEST</version>
  </dependency>
  ```
</CodeGroup>

## 2. Send emails using HTML

```java Main.java theme={null}
import com.resend.*;

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

        CreateEmailOptions params = CreateEmailOptions.builder()
                .from("Acme <onboarding@resend.dev>")
                .to("delivered@resend.dev")
                .subject("it works!")
                .html("<strong>hello world</strong>")
                .build();

         try {
            CreateEmailResponse data = resend.emails().send(params);
            System.out.println(data.getId());
        } catch (ResendException e) {
            e.printStackTrace();
        }
    }
}
```

## 3. Try it yourself

<Card title="Java Examples" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-java-example">
  See the full source code.
</Card>


# Send emails with Laravel
Source: https://resend.com/docs/send-with-laravel

Learn how to send your first email using Laravel.

## Prerequisites

To get the most out of this guide, you will need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

Prefer watching a video? Check out this video walkthrough below.

<YouTube />

## 1. Install

First, install Resend for Laravel using the Composer package manager:

```bash Composer theme={null}
composer require resend/resend-laravel
```

## 2. Configuration

### API key

Next, you should configure your Resend API key in your application's `.env` file:

```ini .env theme={null}
RESEND_API_KEY=re_xxxxxxxxx
```

### Mail driver

To use Resend as your mail driver, first create a new mailer definition, in the `mailers` array within your application's `config/mail.php` configuration file:

```php mail.php theme={null}
'resend' => [
    'transport' => 'resend',
],
```

Next, update your application's `.env` file to use the Resend mail driver:

```ini .env theme={null}
MAIL_MAILER=resend
MAIL_FROM_ADDRESS=onboarding@resend.dev
MAIL_FROM_NAME=Acme
```

## 3. Send an email

Resend for Laravel provides two convenient ways to send emails, using Laravel's email service or the `Resend` API facade.

### Using the Mail Facade

```php OrderShipmentController.php theme={null}
<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Mail\OrderShipped;
use App\Models\Order;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Mail;

class OrderShipmentController extends Controller
{
    /**
     * Ship the given order.
     */
    public function store(Request $request): RedirectResponse
    {
        $order = Order::findOrFail($request->order_id);

        // Ship the order...

        Mail::to($request->user())->send(new OrderShipped($order));

        return redirect('/orders');
    }
}
```

### Using the Resend Facade

```php OrderShipmentController.php theme={null}
<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Mail\OrderShipped;
use App\Models\Order;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Resend\Laravel\Facades\Resend;

class OrderShipmentController extends Controller
{
    /**
     * Ship the given order.
     */
    public function store(Request $request): RedirectResponse
    {
        $order = Order::findOrFail($request->order_id);

        // Ship the order...

        Resend::emails()->send([
            'from' => 'Acme <onboarding@resend.dev>',
            'to' => [$request->user()->email],
            'subject' => 'hello world',
            'html' => (new OrderShipped($order))->render(),
        ])

        return redirect('/orders');
    }
}
```

## 4. Receiving webhook requests

By default, Resend for Laravel includes a webhook controller to respond to the `/resend/webhook` URL path. The controller will dispatch a Laravel event that corresponds to a Resend event. For example, an `email.delivered` event type will send an `EmailDelivered` Laravel event.

### Register the webhook endpoint

Register your publicly accessible HTTPS URL in the Resend dashboard.

<Tip>
  For development, you can create a tunnel to your localhost server using a tool like
  [ngrok](https://ngrok.com/download) or [VS Code Port Forwarding](https://code.visualstudio.com/docs/debugtest/port-forwarding). These tools serve your local dev environment at a public URL you can use to test your local webhook endpoint.

  Example: `https://example123.ngrok.io/api/webhook`
</Tip>

<img alt="Add Webhook" />

### CSRF protection

Webhook requests from Resend need to bypass Laravel's CSRF protection. Be sure to list the URI as an exception in your application's `App\Http\Middleware\VerifyCsrfToken` middleware or list the route outside of the web middleware group:

```php theme={null}
protected $except = [
    'resend/*',
];
```

### Verifying webhook signatures

To enable webhook verification, ensure that the `RESEND_WEBHOOK_SECRET` environment variable is set in your application's `.env` file. The **Signing secret** can be retrieved from your [Resend dashboard](https://resend.com/webhooks).

## 5. Try it yourself

<Card title="Laravel Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-laravel-example">
  See the full source code.
</Card>


# Send emails using Laravel with SMTP
Source: https://resend.com/docs/send-with-laravel-smtp

Learn how to send your first email using Laravel with SMTP.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Setup your environment

First, configure your Resend SMTP details in your application's `.env` file:

```ini .env theme={null}
MAIL_MAILER=smtp
MAIL_HOST=smtp.resend.com
MAIL_PORT=587
MAIL_USERNAME=resend
MAIL_PASSWORD=re_xxxxxxxxx
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=onboarding@resend.dev
MAIL_FROM_NAME=Acme
```

## 2. Send an email

Now you're ready to send emails with Laravel's powerful email service. Here's an example of how you could send your first email using Resend SMTP:

```php OrderShipmentController.php theme={null}
<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Mail\OrderShipped;
use App\Models\Order;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Mail;

class OrderShipmentController extends Controller
{
    /**
     * Ship the given order.
     */
    public function store(Request $request): RedirectResponse
    {
        $order = Order::findOrFail($request->order_id);

        // Ship the order...

        Mail::to($request->user())->send(new OrderShipped($order));

        return redirect('/orders');
    }
}
```

## 3. Try it yourself

<Card title="Laravel Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-laravel-example">
  See the full source code.
</Card>


# Send emails using Liferay with SMTP
Source: https://resend.com/docs/send-with-liferay-smtp

Learn how to integrate Liferay with Resend SMTP.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Get the Resend SMTP credentials

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

## 2. Integrate with Liferay

After logging into your Liferay instance as the admin user, you'll need to enable the SMTP integration.

1. Navigate to **Control Panel** → **Server Administration** → **Mail**.

<img alt="Liferay - SMTP" />

2. Copy-and-paste the SMTP credentials from Resend to Liferay.

* **Outgoing SMTP Server**: `smtp.resend.com`
* **Outgoing Port**: `465`
* **Enable StartTLS**: `True`
* **User Name**: `resend`
* **Password**: `YOUR_API_KEY`

Make sure to replace `YOUR_API_KEY` with an existing key or create a new [API Key](https://resend.com/api-keys).

For the additional JavaMail properties, you can use:

```
mail.smtp.auth=true
mail.smtp.starttls.enable=true
mail.smtp.starttls.required=true
```


# Send emails using Metabase with SMTP
Source: https://resend.com/docs/send-with-metabase-smtp

Learn how to integrate Metabase with Resend SMTP.

### Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Get the Resend SMTP credentials

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

## 2. Integrate with Metabase SMTP

After logging into your [Metabase Cloud](https://www.metabase.com/cloud/login) account, you’ll need to enable the SMTP integration.

1. From your Metabase Cloud Admin Panel, go to **Settings > Email** in the left menu. You should see the form below.

<img alt="Metabase Cloud SMTP" />

2. Copy-and-paste the SMTP credentials from Resend to Metabase Cloud. Finally, click the **Save** button and all of your emails will be sent through Resend.

<img alt="Metabase Cloud SMTP" />


# Send emails using NextAuth with SMTP
Source: https://resend.com/docs/send-with-nextauth-smtp

Learn how to send your first email using NextAuth.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Install the [NextAuth](https://next-auth.js.org/getting-started/example#install-nextauth) package.

<CodeGroup>
  ```bash npm theme={null}
  npm install next-auth
  ```

  ```bash yarn theme={null}
  yarn add next-auth
  ```

  ```bash pnpm theme={null}
  pnpm add next-auth
  ```

  ```bash bun theme={null}
  bun add next-auth
  ```
</CodeGroup>

Then, install the [Nodemailer](https://www.npmjs.com/package/nodemailer) package.

<CodeGroup>
  ```bash npm theme={null}
  npm install nodemailer
  ```

  ```bash yarn theme={null}
  yarn add nodemailer
  ```

  ```bash pnpm theme={null}
  pnpm add nodemailer
  ```

  ```bash bun theme={null}
  bun add nodemailer
  ```
</CodeGroup>

## 2. Configure SMTP credentials

Add your Resend SMTP crendentials in your application's `.env` file:

```ini .env theme={null}
EMAIL_SERVER_USER=resend
EMAIL_SERVER_PASSWORD=YOUR_API_KEY
EMAIL_SERVER_HOST=smtp.resend.com
EMAIL_SERVER_PORT=465
EMAIL_FROM=onboarding@resend.dev
```

## 3. Configure Email Provider

Finally, in your \[...nextauth].js file (typically located in pages/api/auth), configure the Email provider with your SMTP settings:

```js index.ts theme={null}
import NextAuth from 'next-auth';
import EmailProvider from 'next-auth/providers/email';
import nodemailer from 'nodemailer';

export default NextAuth({
  providers: [
    EmailProvider({
      server: {
        host: process.env.EMAIL_SERVER_HOST,
        port: process.env.EMAIL_SERVER_PORT,
        auth: {
          user: process.env.EMAIL_SERVER_USER,
          pass: process.env.EMAIL_SERVER_PASSWORD,
        },
      },
      from: process.env.EMAIL_FROM,
    }),
    // ... other providers as needed
  ],
  // ... any other NextAuth.js configs
});
```


# Send emails with Next.js
Source: https://resend.com/docs/send-with-nextjs

Learn how to send your first email using Next.js and the Resend Node.js SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

Prefer watching a video? Check out our video walkthrough below.

<YouTube />

## 1. Install

Get the Resend Node.js SDK.

<CodeGroup>
  ```bash npm theme={null}
  npm install resend
  ```

  ```bash yarn theme={null}
  yarn add resend
  ```

  ```bash pnpm theme={null}
  pnpm add resend
  ```

  ```bash bun theme={null}
  bun add resend
  ```
</CodeGroup>

## 2. Create an email template

Start by creating your email template on `components/email-template.tsx`.

```tsx components/email-template.tsx theme={null}
import * as React from 'react';

interface EmailTemplateProps {
  firstName: string;
}

export function EmailTemplate({ firstName }: EmailTemplateProps) {
  return (
    <div>
      <h1>Welcome, {firstName}!</h1>
    </div>
  );
}
```

## 3. Send email using React

Create a route file under `app/api/send/route.ts` (or `pages/api/send.ts` if you're using [Pages Router](https://nextjs.org/docs/pages/building-your-application/routing/api-routes)).

Import the React email template and send an email using the `react` parameter.

<CodeGroup>
  ```ts app/api/send/route.ts theme={null}
  import { EmailTemplate } from '../../../components/EmailTemplate';
  import { Resend } from 'resend';

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

  export async function POST() {
    try {
      const { data, error } = await resend.emails.send({
        from: 'Acme <onboarding@resend.dev>',
        to: ['delivered@resend.dev'],
        subject: 'Hello world',
        react: EmailTemplate({ firstName: 'John' }),
      });

      if (error) {
        return Response.json({ error }, { status: 500 });
      }

      return Response.json(data);
    } catch (error) {
      return Response.json({ error }, { status: 500 });
    }
  }
  ```

  ```ts pages/api/send.ts theme={null}
  import type { NextApiRequest, NextApiResponse } from 'next';
  import { EmailTemplate } from '../../components/EmailTemplate';
  import { Resend } from 'resend';

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

  export default async (req: NextApiRequest, res: NextApiResponse) => {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello world',
      react: EmailTemplate({ firstName: 'John' }),
    });

    if (error) {
      return res.status(400).json(error);
    }

    res.status(200).json(data);
  };
  ```
</CodeGroup>

## 4. Try it yourself

<CardGroup>
  <Card title="Next.js Example (App Router)" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-nextjs-app-router-example">
    See the full source code.
  </Card>

  <Card title="Next.js Example (Pages Router)" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-nextjs-pages-router-example">
    See the full source code.
  </Card>
</CardGroup>


# Send emails with Node.js
Source: https://resend.com/docs/send-with-nodejs

Learn how to send your first email using the Resend Node.js SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Node.js SDK.

<CodeGroup>
  ```bash npm theme={null}
  npm install resend
  ```

  ```bash yarn theme={null}
  yarn add resend
  ```

  ```bash pnpm theme={null}
  pnpm add resend
  ```

  ```bash bun theme={null}
  bun add resend
  ```
</CodeGroup>

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```js server.ts theme={null}
import { Resend } from 'resend';

const resend = new Resend('re_xxxxxxxxx');

(async function () {
  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'Hello World',
    html: '<strong>It works!</strong>',
  });

  if (error) {
    return console.error({ error });
  }

  console.log({ data });
})();
```

## 3. Try it yourself

<Card title="Node.js Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-node-example">
  See the full source code.
</Card>


# Send emails using Nodemailer with SMTP
Source: https://resend.com/docs/send-with-nodemailer-smtp

Learn how to send your first email using Nodemailer with SMTP.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the [Nodemailer](https://www.npmjs.com/package/nodemailer) package.

<CodeGroup>
  ```bash npm theme={null}
  npm install nodemailer
  ```

  ```bash yarn theme={null}
  yarn add nodemailer
  ```

  ```bash pnpm theme={null}
  pnpm add nodemailer
  ```

  ```bash bun theme={null}
  bun add nodemailer
  ```
</CodeGroup>

## 2. Send email using SMTP

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

Then use these credentials to create a transport:

```js index.ts theme={null}
import nodemailer from 'nodemailer';

async function main() {
  const transporter = nodemailer.createTransport({
    host: 'smtp.resend.com',
    secure: true,
    port: 465,
    auth: {
      user: 'resend',
      pass: 're_xxxxxxxxx',
    },
  });

  const info = await transporter.sendMail({
    from: 'onboarding@resend.dev',
    to: 'delivered@resend.dev',
    subject: 'Hello World',
    html: '<strong>It works!</strong>',
  });

  console.log('Message sent: %s', info.messageId);
}

main().catch(console.error);
```

## 3. Try it yourself

<Card title="Nodemailer SMTP Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-nodemailer-smtp-example">
  See the full source code.
</Card>


# Send emails with Nuxt
Source: https://resend.com/docs/send-with-nuxt

Learn how to send your first email using Nuxt and the Resend Node.js SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Node.js SDK.

<CodeGroup>
  ```bash npm theme={null}
  npm install resend
  ```

  ```bash yarn theme={null}
  yarn add resend
  ```

  ```bash pnpm theme={null}
  pnpm add resend
  ```

  ```bash bun theme={null}
  bun add resend
  ```
</CodeGroup>

## 2. Send email using HTML

Create a [Server Route](https://nuxt.com/docs/guide/directory-structure/server) under `server/api/send.ts`.

The easiest way to send an email is by using the `html` parameter.

<CodeGroup>
  ```ts server/api/send.ts theme={null}
  import { Resend } from 'resend';

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

  export default defineEventHandler(async () => {
    const response = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello world',
      html: '<strong>It works!</strong>',
    });

    if (response.error) {
      throw createError({
        statusCode: 500,
        message: 'Error sending email',
      });
    }

    return response;
  });
  ```
</CodeGroup>

## 3. Try it yourself

<Card title="Nuxt Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-nuxt-example">
  See the full source code.
</Card>


# Send emails with Phoenix
Source: https://resend.com/docs/send-with-phoenix

Learn how to send your first email using Phoenix and the Resend Elixir SDK.

<Info>
  This guides utilizes an [open source
  library](https://github.com/elixir-saas/resend-elixir) contributed by a
  community member. It's not developed, maintained, or supported by Resend
  directly.
</Info>

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Install by adding `resend` to your list of dependencies in `mix.exs`:

<CodeGroup>
  ```elixir mix.exs theme={null}
  def deps do
    [
      {:resend, "~> 0.4.5"}
    ]
  end
  ```
</CodeGroup>

## 2. Send email using Swoosh

This library includes a Swoosh adapter to make using Resend with a new Phoenix project as easy as possible. All you have to do is configure your Mailer:

```elixir theme={null}
config :my_app, MyApp.Mailer,
  adapter: Resend.Swoosh.Adapter,
  api_key: System.fetch_env!("RESEND_API_KEY")
```

If you're configuring your app for production, configure your adapter in `prod.exs`, and your API key from the environment in `runtime.exs`:

<CodeGroup>
  ```elixir prod.exs theme={null}
  config :my_app, MyApp.Mailer, adapter: Resend.Swoosh.Adapter
  ```

  ```elixir runtime.exs theme={null}
  config :my_app, MyApp.Mailer, api_key: "re_xxxxxxxxx"
  ```
</CodeGroup>

## 3. Try it yourself

<Card title="Phoenix Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-phoenix-example">
  See the full source code.
</Card>


# Send emails with PHP
Source: https://resend.com/docs/send-with-php

Learn how to send your first email using the Resend PHP SDK.

## Prerequisites

To get the most out of this guide, you will need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

Prefer watching a video? Check out this video walkthrough below.

<YouTube />

## 1. Install

Get the Resend PHP SDK.

```bash Composer theme={null}
composer require resend/resend-php
```

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```php index.php theme={null}
<?php

require __DIR__ . '/vendor/autoload.php';

$resend = Resend::client('re_xxxxxxxxx');

$resend->emails->send([
  'from' => 'Acme <onboarding@resend.dev>',
  'to' => ['delivered@resend.dev'],
  'subject' => 'hello world',
  'html' => '<strong>it works!</strong>',
]);
```

## 3. Try it yourself

<Card title="PHP Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-php-example">
  See the full source code.
</Card>


# Send emails using PHPMailer with SMTP
Source: https://resend.com/docs/send-with-phpmailer-smtp

Learn how to send your first email using PHPMailer with SMTP.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the [PHPMailer](https://github.com/PHPMailer/PHPMailer) package.

<CodeGroup>
  ```bash php theme={null}
  composer require phpmailer/phpmailer
  ```
</CodeGroup>

## 2. Send email using SMTP

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `587`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

Then use these credentials to send with PHPMailer:

```php theme={null}
<?php

// Include Composer autoload file to load PHPMailer classes
require __DIR__ . '/vendor/autoload.php';

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

$mail = new PHPMailer(true);

try {
    $mail->isSMTP();
    $mail->Host = 'smtp.resend.com';
    $mail->SMTPAuth = true;
    $mail->Username = 'resend';
    $mail->Password = 're_xxxxxxxxx';
    $mail->SMTPSecure = 'tls';
    $mail->Port = 587;

    // Set email format to HTML
    $mail->isHTML(true);

    $mail->setFrom('onboarding@resend.dev');
    $mail->addAddress('delivered@resend.dev');
    $mail->Subject = 'Hello World';
    $mail->Body = '<strong>It works!</strong>';

    $mail->send();

    // Log the successfully sent message
    echo 'Email successfully sent';
} catch (Exception $e) {
    // Log the detailed error for debugging
    error_log('Mailer Error: ' . $mail->ErrorInfo);
    // Show a generic error message to the user
    echo 'There was an error sending the email.';
}
```

## 3. Try it yourself

<Card title="PHPMailer SMTP Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-phpmailer-smtp-example">
  See the full source code.
</Card>


# Send emails with Python
Source: https://resend.com/docs/send-with-python

Learn how to send your first email using the Resend Python SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Python SDK.

<CodeGroup>
  ```bash Pip theme={null}
  pip install resend
  ```
</CodeGroup>

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```py index.py theme={null}
import os
import resend

resend.api_key = os.environ["RESEND_API_KEY"]

params: resend.Emails.SendParams = {
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "hello world",
    "html": "<strong>it works!</strong>",
}

email = resend.Emails.send(params)
print(email)
```

## 3. Try it yourself

<Card title="Python Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-python-example">
  See the full source code.
</Card>


# Send emails with Rails
Source: https://resend.com/docs/send-with-rails

Learn how to send your first email using Rails and the Resend Ruby SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Ruby SDK.

<CodeGroup>
  ```bash RubyGems theme={null}
  gem install resend
  ```

  ```bash Gemfile theme={null}
  gem 'resend'
  ```
</CodeGroup>

## 2. Send email using Rails Action Mailer

This gem can be used as an Action Mailer delivery method.

First, let's update or create your mailer initializer file with your Resend API Key.

```rb config/initializers/mailer.rb theme={null}
Resend.api_key = "re_xxxxxxxxx"
```

Add these lines of code into your environment config file.

```rb config/environments/environment.rb theme={null}
config.action_mailer.delivery_method = :resend
```

Then create a `UserMailer` class definition.

```rb app/mailers/user_mailer.rb theme={null}
class UserMailer < ApplicationMailer
  default from: 'Acme <onboarding@resend.dev>' # this domain must be verified with Resend
  def welcome_email
    @user = params[:user]
    @url = 'http://example.com/login'
    mail(to: ["delivered@resend.dev"], subject: 'hello world')
  end
end
```

And create your ERB email template.

```html app/views/user_mailer/welcome_email.html.erb theme={null}
<!doctype html>
<html>
  <head>
    <meta content="text/html; charset=UTF-8" http-equiv="Content-Type" />
  </head>
  <body>
    <h1>Welcome to example.com, <%= @user.name %></h1>
    <p>You have successfully signed up to example.com,</p>
    <p>To log in to the site, just follow this link: <%= @url %>.</p>
    <p>Thanks for joining and have a great day!</p>
  </body>
</html>
```

Initialize your `UserMailer` class. This should return a `UserMailer` instance.

```rb theme={null}
u = User.new name: "derich"
mailer = UserMailer.with(user: u).welcome_email

# => #<Mail::Message:153700, Multipart: false, Headers: <From: from@example.com>, <To: to@example.com>, <Subject: hello world>, <Mime-Version: 1.0>...
```

Finally, you can now send emails using the `deliver_now!` method:

```rb theme={null}
mailer.deliver_now!

# => {:id=>"a193c81e-9ac5-4708-a569-5caf14220539", :from=>....}
```

## 3. Try it yourself

<Card title="Rails Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-rails-example">
  See the full source code.
</Card>


# Send emails using Rails with SMTP
Source: https://resend.com/docs/send-with-rails-smtp

Learn how to integrate Rails with Resend SMTP.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Setup your environment

Add these lines of code into your environment config file.

```rb config/environments/environment.rb theme={null}
config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = {
  :address   => 'smtp.resend.com',
  :port      => 465,
  :user_name => 'resend',
  :password  => ENV['RESEND_API_KEY'],
  :tls => true
}
```

## 2. Send email using Rails Action Mailer

Then create a `UserMailer` class definition.

```rb app/mailers/user_mailer.rb theme={null}
class UserMailer < ApplicationMailer
  default from: 'Acme <onboarding@resend.dev>' # this domain must be verified with Resend
  def welcome_email
    @user = params[:user]
    @url = 'http://example.com/login'
    mail(to: ["delivered@resend.dev"], subject: 'hello world')
  end
end
```

And create your ERB email template.

```html app/views/user_mailer/welcome_email.html.erb theme={null}
<!doctype html>
<html>
  <head>
    <meta content="text/html; charset=UTF-8" http-equiv="Content-Type" />
  </head>
  <body>
    <h1>Welcome to example.com, <%= @user.name %></h1>
    <p>You have successfully signed up to example.com,</p>
    <p>To log in to the site, just follow this link: <%= @url %>.</p>
    <p>Thanks for joining and have a great day!</p>
  </body>
</html>
```

Initialize your `UserMailer` class. This should return a `UserMailer` instance.

```rb theme={null}
u = User.new name: "derich"
mailer = UserMailer.with(user: u).welcome_email

# => #<Mail::Message:153700, Multipart: false, Headers: <From: from@example.com>, <To: to@example.com>, <Subject: hello world>, <Mime-Version: 1.0>...
```

Finally, you can now send emails using the `deliver_now!` method:

```rb theme={null}
mailer.deliver_now!

# => {:id=>"a193c81e-9ac5-4708-a569-5caf14220539", :from=>....}
```

## 3. Try it yourself

<Card title="Rails SMTP Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-rails-smtp-example">
  See the full source code.
</Card>


# Send emails with Railway
Source: https://resend.com/docs/send-with-railway

Learn how to send your first email using Railway and the Resend Node.js SDK.

[Railway](https://railway.com/?referralCode=resend) enables you to focus on building product instead of managing infrastructure, automatically scaling to support your needs as you grow.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

We've created a [Resend template](https://railway.com/deploy/resend?referralCode=resend\&utm_medium=integration\&utm_source=template\&utm_campaign=generic) using the Resend Node.js SDK as an introduction to using Resend on Railway.

To get started, you deploy the template to Railway.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/resend?referralCode=resend\&utm_medium=integration\&utm_source=template\&utm_campaign=generic)

<img alt="Deploy button highlighted on Railway" />

## 2. Add your API key

[Add an API key](https://resend.com/api-keys) from Resend and click **Deploy**.

<img alt="Template modal with API key field highlighted" />

## 3. Send your first email

Once your deployment finishes, click the deploy URL to open the app and send your first email.

<img alt="Deployment link highlighted" />

While this example uses the [Resend Node.js SDK](https://www.npmjs.com/package/@resend/node), you can add Resend using [any of our Official SDKs](https://resend.com/docs/sdks) that Railway supports.

<Info>
  Keep in mind that as a basic project, this template sends an email with your
  account each time someone visits your deployment URL, so share the link with
  discretion.
</Info>

You can also [set up the project locally](https://docs.railway.com/develop/cli) and make changes to the projectusing the Railway CLI.

## 4. Try it yourself

<Card title="Railway Template" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-node-railway-starter">
  See the full source code.
</Card>


# Send emails with RedwoodJS
Source: https://resend.com/docs/send-with-redwoodjs

Learn how to send your first email using Redwood.js and the Resend Node.js SDK.

### Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

### 1. Install

Get the Resend Node.js SDK.

<CodeGroup>
  ```bash yarn theme={null}
  yarn workspace api add resend
  ```
</CodeGroup>

### 2. Send email using HTML

```bash theme={null}
yarn rw g function send
```

The easiest way to send an email is by using the `html` parameter.

```ts api/src/functions/send/send.ts theme={null}
import { Resend } from 'resend';
import type { APIGatewayEvent, Context } from 'aws-lambda';

const resend = new Resend('re_xxxxxxxxx');

export const handler = async (event: APIGatewayEvent, context: Context) => {
  const { data, error } = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<strong>it works!</strong>',
  });

  if (error) {
    return {
      statusCode: 500,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ error }),
    };
  }

  return {
    statusCode: 200,
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ data }),
  };
};
```

### 3. Try it yourself

<Card title="Redwood.js Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-redwoodjs-example">
  See the full source code.
</Card>


# Send emails with Remix
Source: https://resend.com/docs/send-with-remix

Learn how to send your first email using Remix and the Resend Node.js SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Node.js SDK.

<CodeGroup>
  ```bash npm theme={null}
  npm install resend
  ```

  ```bash yarn theme={null}
  yarn add resend
  ```

  ```bash pnpm theme={null}
  pnpm add resend
  ```

  ```bash bun theme={null}
  bun add resend
  ```
</CodeGroup>

## 2. Send email using HTML

Create a [Resource Route](https://remix.run/docs/en/1.16.1/guides/resource-routes) under `app/routes/send.ts`.

The easiest way to send an email is by using the `html` parameter.

<CodeGroup>
  ```ts app/routes/send.ts theme={null}
  import { json } from '@remix-run/node';
  import { Resend } from 'resend';

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

  export const loader = async () => {
    const { data, error } = await resend.emails.send({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'Hello world',
      html: '<strong>It works!</strong>',
    });

    if (error) {
      return json({ error }, 400);
    }

    return json(data, 200);
  };
  ```
</CodeGroup>

## 3. Try it yourself

<Card title="Remix Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-remix-example">
  See the full source code.
</Card>


# Send emails using Retool with SMTP
Source: https://resend.com/docs/send-with-retool-smtp

Learn how to integrate Retool with Resend SMTP.

### Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Get the Resend SMTP credentials

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

## 2. Integrate with Retool SMTP

Log into your [Retool](https://retool.com) account and create a new SMTP Resource.

1. Go to **Resources** and click **Create New**

<img alt="Retool SMTP - Create new Resources" />

2. Search for **SMTP** and select it

<img alt="Retool SMTP - Search for SMTP" />

3. Add name and SMTP credentials

<img alt="Retool SMTP - Add SMTP credentials" />


# Send emails with Ruby
Source: https://resend.com/docs/send-with-ruby

Learn how to send your first email using the Resend Ruby SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Ruby SDK.

<CodeGroup>
  ```bash RubyGems theme={null}
  gem install resend
  ```

  ```bash Gemfile theme={null}
  gem 'resend'
  ```
</CodeGroup>

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```rb index.rb theme={null}
require "resend"

Resend.api_key = "re_xxxxxxxxx"

params = {
  "from": "Acme <onboarding@resend.dev>",
  "to": ["delivered@resend.dev"],
  "subject": "hello world",
  "html": "<strong>it works!</strong>"
}

sent = Resend::Emails.send(params)
puts sent
```

## 3. Try it yourself

<Card title="Ruby Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-ruby-example">
  See the full source code.
</Card>


# Send emails with Rust
Source: https://resend.com/docs/send-with-rust

Learn how to send your first email using the Resend Rust SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)

## Install

First, create a rust project with cargo and `cd` into it.

```bash theme={null}
cargo init resend-rust-example
cd resend-rust-example
```

Next, add add the Rust Resend SDK as well as [Tokio](https://tokio.rs):

```bash theme={null}
cargo add resend-rs
cargo add tokio -F macros,rt-multi-thread
```

The Rust SDK is Async-first so Tokio is needed.

## Send email

```rust theme={null}
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

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

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Hello World";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<strong>It works!</strong>");

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

## Reading the API key

Instead of using `Resend::new` and hardcoding the API key, the `RESEND_API_KEY` environment variable
can be used instead. The `Resend::default()` should be used in that scenario instead.

### Reading the API key from a `.env` file

Another popular option is to use a `.env` file for environment variables. You can use the
[`dotenvy`](https://crates.io/crates/dotenvy) crate for that:

```bash theme={null}
cargo add dotenvy
```

```rust theme={null}
// main.rs
use dotenvy::dotenv;
use resend_rs::types::CreateEmailBaseOptions;
use resend_rs::{Resend, Result};

#[tokio::main]
async fn main() -> Result<()> {
  let _env = dotenv().unwrap();

  let resend = Resend::default();

  let from = "Acme <onboarding@resend.dev>";
  let to = ["delivered@resend.dev"];
  let subject = "Hello World";

  let email = CreateEmailBaseOptions::new(from, to, subject)
    .with_html("<strong>It works!</strong>");

  let _email = resend.emails.send(email).await?;

  Ok(())
}
```

```toml theme={null}
# .env
RESEND_API_KEY=re_xxxxxxxxx
```

## 3. Try it yourself

<Card title="Rust Examples" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-rust-example">
  See the full source code.
</Card>


# Send emails with Sinatra
Source: https://resend.com/docs/send-with-sinatra

Learn how to send your first email using Sinatra and the Resend Ruby SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Ruby SDK.

<CodeGroup>
  ```bash RubyGems theme={null}
  gem install resend
  ```

  ```bash Gemfile theme={null}
  gem 'resend'
  ```
</CodeGroup>

## 2. Send email using HTML

The easiest way to send an email is by using the `html` parameter.

```rb index.rb theme={null}
require "sinatra"
require "resend"

set :port, 5000
set :bind, "0.0.0.0"

Resend.api_key = ENV["RESEND_API_KEY"]

get "/" do

  content_type :json

  params = {
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<strong>it works!</strong>',
  }

  Resend::Emails.send(params).to_hash.to_json
end
```

## 3. Try it yourself

<Card title="Sinatra Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-sinatra-example">
  See the full source code.
</Card>


# Send emails with SMTP
Source: https://resend.com/docs/send-with-smtp

Learn how to integrate Resend via SMTP.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

Prefer watching a video? Check out our video walkthrough below.

<YouTube />

## SMTP Credentials

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `25`, `465`, `587`, `2465`, or `2587`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

Ports help to instruct the type of security you want to use in your SMTP connection.

| Type     | Port                | Security                                                                  |
| -------- | ------------------- | ------------------------------------------------------------------------- |
| SMTPS    | `465`, `2465`       | Implicit SSL/TLS (Immediately connects via SSL/TLS)                       |
| STARTTLS | `25`, `587`, `2587` | Explicit SSL/TLS (First connects via plaintext, then upgrades to SSL/TLS) |

## Idempotency Key

Idempotency keys are used to prevent duplicate emails. You can add the `Resend-Idempotency-Key` header to your emails sent with SMTP to prevent duplicate emails.

```yaml SMTP {4} theme={null}
From: Acme <onboarding@resend.dev>
To: delivered@resend.dev
Subject: hello world
Resend-Idempotency-Key: welcome-user/123456789

<p>it works!</p>
```

Learn more about [idempotency keys](/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 should be able to start sending emails via SMTP. Below are some frequently asked questions:

<AccordionGroup>
  <Accordion title="What if I need logs from the server to debug?">
    We currently don't provide SMTP server logs for debugging. If you run into
    issues, please [reach out to support](https://resend.com/help).
  </Accordion>

  <Accordion title="Where do I see the emails sent with SMTP?">
    Emails sent with SMTP will show in your [emails
    table](https://resend.com/emails).
  </Accordion>

  <Accordion title="Does the rate limit apply when sending with SMTP?">
    Yes, the rate limit is the [same as the
    API](https://resend.com/docs/api-reference/introduction#rate-limit).
  </Accordion>
</AccordionGroup>


# Send emails with Supabase Edge Functions
Source: https://resend.com/docs/send-with-supabase-edge-functions

Learn how to send your first email using Supabase Edge Functions.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

Make sure you have the latest version of the [Supabase CLI](https://supabase.com/docs/guides/cli#installation) installed.

## 1. Create Supabase function

Create a new function locally:

```bash theme={null}
supabase functions new resend
```

## 2. Edit the handler function

Paste the following code into the `index.ts` file:

```ts index.ts theme={null}
const RESEND_API_KEY = Deno.env.get('RESEND_API_KEY');

const handler = async (_request: Request): Promise<Response> => {
  const res = await fetch('https://api.resend.com/emails', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${RESEND_API_KEY}`,
    },
    body: JSON.stringify({
      from: 'Acme <onboarding@resend.dev>',
      to: ['delivered@resend.dev'],
      subject: 'hello world',
      html: '<strong>it works!</strong>',
    }),
  });

  const data = await res.json();

  return new Response(JSON.stringify(data), {
    status: 200,
    headers: {
      'Content-Type': 'application/json',
    },
  });
};

Deno.serve(handler);
```

## 3. Deploy and send email

Run function locally:

```bash theme={null}
supabase functions start
supabase functions serve resend --no-verify-jwt
```

Deploy function to Supabase:

```bash theme={null}
supabase functions deploy resend
```

Open the endpoint URL to send an email:

<img alt="Supabase Edge Functions - Deploy Function" />

## 4. Try it yourself

<Card title="Supabase Edge Functions Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-supabase-edge-functions-example">
  See the full source code.
</Card>


# Send emails using Supabase with SMTP
Source: https://resend.com/docs/send-with-supabase-smtp

Learn how to integrate Supabase Auth with Resend SMTP.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Get the Resend SMTP credentials

When configuring your SMTP integration, you'll need to use the following credentials:

* **Host**: `smtp.resend.com`
* **Port**: `465`
* **Username**: `resend`
* **Password**: `YOUR_API_KEY`

## 2. Integrate with Supabase SMTP

After logging into your Supabase account, you'll need to enable the SMTP integration.

1. Go to your Supabase project
2. Click on **Project Settings** in the left sidebar
3. Select the **Authentication** tab
4. Find the SMTP section and toggle the **Enable Custom SMTP** option
5. Add your Sender email and name (these are required fields). For example: `support@acme.com` and `ACME Support`.

<img alt="Supabase Auth - SMTP Sender email and name settings" />

6. You can copy-and-paste the [SMTP credentials](https://resend.com/settings/smtp) from Resend to Supabase.

<img alt="Supabase Auth - SMTP Settings" />

After that, you can click the **Save** button and all of your emails will be sent through Resend.


# Send emails with SvelteKit
Source: https://resend.com/docs/send-with-sveltekit

Learn how to send your first email using SvelteKit and the Resend Node.js SDK.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Node.js SDK.

<CodeGroup>
  ```bash npm theme={null}
  npm install resend
  ```

  ```bash yarn theme={null}
  yarn add resend
  ```

  ```bash pnpm theme={null}
  pnpm add resend
  ```

  ```bash bun theme={null}
  bun add resend
  ```
</CodeGroup>

## 2. Send email using HTML

Create a [+server API route](https://svelte.dev/docs/kit/routing#server) under `src/routes/send/+server.ts`.

The easiest way to send an email is by using the `html` parameter.

<CodeGroup>
  ```ts src/routes/send/+server.ts theme={null}
  import { Resend } from 'resend';
  import { RESEND_API_KEY } from '$env/static/private'; // define in your .env file

  const resend = new Resend(RESEND_API_KEY);

  export async function POST() {
    try {
      const { data, error } = await resend.emails.send({
        from: 'Acme <onboarding@resend.dev>',
        to: ['delivered@resend.dev'],
        subject: 'Hello world',
        html: '<p>Hello world</p>',
      });

      if (error) {
        return Response.json({ error }, { status: 500 });
      }

      return Response.json({ data });
    } catch (error) {
      return Response.json({ error }, { status: 500 });
    }
  }
  ```
</CodeGroup>

## 3. Try it yourself

<CardGroup>
  <Card title="SvelteKit Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-svelte-kit-example">
    See the full source code.
  </Card>
</CardGroup>


# Send emails with Symfony
Source: https://resend.com/docs/send-with-symfony

Learn how to send your first email using the Symfony Resend Mailer Bridge.

## Prerequisites

To get the most out of this guide, you will need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install

Get the Resend Mailer Bridge package.

```bash Composer theme={null}
composer require symfony/resend-mailer
```

If your application relies on Resend webhook events, you should also install the Symfony Webhook Component.

```bash Composer theme={null}
composer require symfony/webhook
```

## 2. Configuring Mailer

In your `.env.local` file, which you can create if needed, add the following:

```sh theme={null}
MAILER_DSN=resend+api://API_KEY@default
MAILER_RESEND_SECRET=SIGNING_SECRET
```

Replace `API_KEY` with your Resend API key, and `SIGNING_SECRET` with your webhook secret, which can be retrieved from the Resend dashboard after creating a new webhook endpoint (see below).

## 3. Send your first email

In a controller, inject the `Mailer`:

```php theme={null}
public function __construct(
    private readonly MailerInterface $mailer,
) {
}
```

In a controller action, use the `$this->mailer` to send your email:

```php theme={null}
$this->mailer->send(
    (new Email())
        ->from('Acme <onboarding@resend.dev>')
        ->to('delivered@resend.dev')
        ->subject('Hello world')
        ->html('<strong>it works!</strong>')
);
```

Learn more about sending emails with Mailer Component in [Symfony's documentation](https://symfony.com/doc/current/mailer.html#creating-sending-messages).

## 4. Receive and handle webhooks

Thanks to the Webhook Component, you can create a webhook listener.

```php src/Webhook/ResendWebhookListener.php theme={null}
#[AsRemoteEventConsumer('mailer_resend')]
readonly class ResendWebhookListener implements ConsumerInterface
{
    public function __construct(
        #[Autowire(param: 'kernel.project_dir')] private string $projectDir,
    ) {
    }

    public function consume(RemoteEvent $event): void
    {
        if ($event instanceof MailerDeliveryEvent) {
            $this->handleMailDelivery($event);
        } elseif ($event instanceof MailerEngagementEvent) {
            $this->handleMailEngagement($event);
        } else {
            // This is not an email event
            return;
        }
    }

    private function handleMailDelivery(MailerDeliveryEvent $event): void
    {
        // Todo
    }

    private function handleMailEngagement(MailerEngagementEvent $event): void
    {
        // Todo
    }
}
```

Bind your listener to the Webhook routing config:

```yaml config/packages/webhook.yaml theme={null}
framework:
  webhook:
    routing:
      mailer_resend:
        service: 'mailer.webhook.request_parser.resend'
        secret: '%env(MAILER_RESEND_SECRET)%'
```

Next, register your application's webhook endpoint URL (example: `https://{app_domain}/webhook/mailer_resend`) in the [Resend Dashboard](https://resend.com/webhooks):

## 5. Try it yourself

<Card title="Symfony Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-symfony-example">
  See the full source code.
</Card>


# Send emails with Vercel Functions
Source: https://resend.com/docs/send-with-vercel-functions

Learn how to send your first email using Vercel Functions.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

Make sure you have the latest version of the [Vercel CLI](https://vercel.com/docs/cli#installing-vercel-cli) installed.

## 1. Install dependencies

Install the Resend SDK:

```bash theme={null}
npm install resend
```

## 2. Set up environment variables

Add your Resend API key to your environment variables:

```bash .env.local theme={null}
RESEND_API_KEY=re_xxxxxxxxx
```

## 3. Create a Next.js function

Create a route file under `app/api/send/route.ts` if you're using the [App Router](https://nextjs.org/docs/app/building-your-application/routing/router-handlers).

```ts route.ts theme={null}
import { Resend } from 'resend';

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

export async function POST() {
  const response = await resend.emails.send({
    from: 'Acme <onboarding@resend.dev>',
    to: ['delivered@resend.dev'],
    subject: 'hello world',
    html: '<strong>it works!</strong>',
  });

  return Response.json(response, {
    status: response.error ? 500 : 200,
  });
}
```

## 4. Send email locally

Run function locally:

```bash theme={null}
npm run dev
```

Open the endpoint URL to send an email: `http://localhost:3000/api/send`

## 5. Send email in production

Deploy function to Vercel:

```bash theme={null}
vercel
```

Make sure to add your `RESEND_API_KEY` environment variable in your Vercel project settings.

Open the endpoint URL to send an email: `https://your-project.vercel.app/api/send`

## 6. Try it yourself

<Card title="Vercel Functions Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-vercel-functions-example">
  See the full source code.
</Card>


# Send emails using WordPress with SMTP
Source: https://resend.com/docs/send-with-wordpress-smtp

Learn how to send your first email using Wordpress.

## Prerequisites

To get the most out of this guide, you'll need to:

* [Create an API key](https://resend.com/api-keys)
* [Verify your domain](https://resend.com/domains)

## 1. Install a plugin

First, you'll need to install and activate the [WP Mail SMTP](https://wordpress.org/plugins/wp-mail-smtp/) plugin. Once the plugin is activated you will see the setup wizard. You can skip this step as we'll guide you through how to configure the plugin for Resend. Just click on **Go to the Dashboard** at the bottom of the screen to exit the setup wizard.

<img alt="WP Mail SMTP - Setup Wizard" />

## 2. Configuration

From your admin dashboard, visit the **WP Mail SMTP > Settings** page to configure the plugin. Firstly, configure your **From Email**, **From Name**, and **Return Path**. Next, we'll configure the SMTP settings for Resend. Select **Other SMTP** in the **Mailer** section.

<img alt="WP Mail SMTP - Settings" />

In the **Other SMTP** section, configure the following settings:

* **SMTP Host**: `smtp.resend.com`
* **Encryption**: `SSL`
* **SMTP Port**: `465`
* **Auto TLS**: `ON`
* **Authentication**: `ON`
* **SMTP Username**: `resend`
* **SMTP Password**: `YOUR_API_KEY`

Make sure to replace `YOUR_API_KEY` with an existing key or create a new [API Key](https://resend.com/api-keys).

## 3. Sending a test email

From your admin dashboard, visit the **WP Mail SMTP > Tools** page to send a test email.

<img alt="WP Mail SMTP - Send a Test Email" />


# contact.created
Source: https://resend.com/docs/webhooks/contacts/created

Received when a contact is created.

Event triggered whenever a **contact was successfully created**.

*Note: When importing multiple contacts using CSV, these events won't be triggered. [Contact support](https://resend.com/contact) if you have any questions.*

<ResponseBodyParameters type="contact.created">
  <ParamField type="string">
    Unique identifier for the contact
  </ParamField>

  <ParamField type="string">
    Unique identifier for the audience this contact belongs to
  </ParamField>

  <ParamField type="array">
    Array of segment IDs the contact belongs to
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the contact was created
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the contact was last updated
  </ParamField>

  <ParamField type="string">
    Contact's email address
  </ParamField>

  <ParamField type="string">
    Contact's first name
  </ParamField>

  <ParamField type="string">
    Contact's last name
  </ParamField>

  <ParamField type="boolean">
    Whether the contact has unsubscribed from all emails sent from your team
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "contact.created",
    "created_at": "2024-11-17T19:32:22.980Z",
    "data": {
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      "segment_ids": ["78261eea-8f8b-4381-83c6-79fa7120f1cf"],
      "created_at": "2024-11-17T19:32:22.980Z",
      "updated_at": "2024-11-17T19:32:22.980Z",
      "email": "steve.wozniak@gmail.com",
      "first_name": "Steve",
      "last_name": "Wozniak",
      "unsubscribed": false
    }
  }
  ```
</ResponseExample>


# contact.deleted
Source: https://resend.com/docs/webhooks/contacts/deleted

Received when a contact is deleted.

Event triggered whenever a **contact was successfully deleted**.

<ResponseBodyParameters type="contact.deleted">
  <ParamField type="string">
    Unique identifier for the contact
  </ParamField>

  <ParamField type="string">
    Unique identifier for the audience this contact belongs to
  </ParamField>

  <ParamField type="array">
    Array of segment IDs the contact belongs to
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the contact was created
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the contact was last updated
  </ParamField>

  <ParamField type="string">
    Contact's email address
  </ParamField>

  <ParamField type="string">
    Contact's first name
  </ParamField>

  <ParamField type="string">
    Contact's last name
  </ParamField>

  <ParamField type="boolean">
    Whether the contact has unsubscribed from all emails sent from your team
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "contact.deleted",
    "created_at": "2024-11-17T19:32:22.980Z",
    "data": {
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      "segment_ids": ["78261eea-8f8b-4381-83c6-79fa7120f1cf"],
      "created_at": "2024-11-10T15:11:94.110Z",
      "updated_at": "2024-11-17T19:32:22.980Z",
      "email": "steve.wozniak@gmail.com",
      "first_name": "Steve",
      "last_name": "Wozniak",
      "unsubscribed": false
    }
  }
  ```
</ResponseExample>


# contact.updated
Source: https://resend.com/docs/webhooks/contacts/updated

Received when a contact is updated.

Event triggered whenever a **contact was successfully updated**.

<ResponseBodyParameters type="contact.updated">
  <ParamField type="string">
    Unique identifier for the contact
  </ParamField>

  <ParamField type="string">
    Unique identifier for the audience this contact belongs to
  </ParamField>

  <ParamField type="array">
    Array of segment IDs the contact belongs to
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the contact was created
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the contact was last updated
  </ParamField>

  <ParamField type="string">
    Contact's email address
  </ParamField>

  <ParamField type="string">
    Contact's first name
  </ParamField>

  <ParamField type="string">
    Contact's last name
  </ParamField>

  <ParamField type="boolean">
    Whether the contact has unsubscribed from all emails sent from your team
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "contact.updated",
    "created_at": "2024-10-11T23:47:56.678Z",
    "data": {
      "id": "e169aa45-1ecf-4183-9955-b1499d5701d3",
      "audience_id": "78261eea-8f8b-4381-83c6-79fa7120f1cf",
      "segment_ids": ["78261eea-8f8b-4381-83c6-79fa7120f1cf"],
      "created_at": "2024-10-10T15:11:94.110Z",
      "updated_at": "2024-10-11T23:47:56.678Z",
      "email": "steve.wozniak@gmail.com",
      "first_name": "Steve",
      "last_name": "Wozniak",
      "unsubscribed": false
    }
  }
  ```
</ResponseExample>


# domain.created
Source: https://resend.com/docs/webhooks/domains/created

Received when a domain is created.

Event triggered when a **domain was successfully created**.

<Info>
  If you're having issues verifying your domain, [review our guide on a domain
  not verifying](/knowledge-base/what-if-my-domain-is-not-verifying) for
  troubleshooting steps.
</Info>

<ResponseBodyParameters type="domain.created">
  <ParamField type="string">
    Unique identifier for the domain
  </ParamField>

  <ParamField type="string">
    Domain name (e.g., `example.com`)
  </ParamField>

  <ParamField type="verified | partially_failed | failed | pending | not_started">
    Current verification status of the domain:

    * `verified`: The domain is verified and can be used to send or receive emails.
    * `partially_failed`: The domain is verified but one of the features (send or receive) is not verified.
    * `pending`: The domain is pending verification and cannot be used to send or receive emails.
    * `not_started`: Verification has not started yet, so the domain cannot be used to send or receive emails.
    * `failed`: The domain failed verification.

    <Note>
      The `data.status` field represents an aggregated status of the domain. For
      domains that can both [send](/dashboard/emails/introduction) and
      [receive](/dashboard/receiving/introduction) emails, the status may be
      `partially_failed`, which indicates that one of these features is verified
      while the other is not.
    </Note>
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the domain was created
  </ParamField>

  <ParamField type="us-east-1 | eu-west-1 | sa-east-1 | ap-northeast-1">
    AWS region where the domain is configured.
  </ParamField>

  <ParamField type="array">
    Array of DNS record objects required for domain verification

    <Expandable title="record object">
      <ParamField type="SPF | DKIM | Receiving MX">
        Record type purpose. Learn more about [domain verification records](/dashboard/domains/introduction).
      </ParamField>

      <ParamField type="string">
        DNS record name/subdomain
      </ParamField>

      <ParamField type="MX | TXT | CNAME">
        DNS record type
      </ParamField>

      <ParamField type="string">
        DNS record value to be set
      </ParamField>

      <ParamField type="string">
        Time to live for the DNS record
      </ParamField>

      <ParamField type="string">
        Verification status of this specific record
      </ParamField>

      <ParamField type="number">
        Priority value for MX records (optional)
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "domain.created",
    "created_at": "2024-11-17T19:32:22.980Z",
    "data": {
      "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
      "name": "example.com",
      "status": "not_started",
      "created_at": "2024-04-26T20:21:26.347412+00:00",
      "region": "us-east-1",
      "records": [
        {
          "record": "SPF",
          "name": "send",
          "type": "MX",
          "ttl": "Auto",
          "status": "not_started",
          "value": "feedback-smtp.us-east-1.amazonses.com",
          "priority": 10
        },
        {
          "record": "SPF",
          "name": "send",
          "value": "\"v=spf1 include:amazonses.com ~all\"",
          "type": "TXT",
          "ttl": "Auto",
          "status": "not_started"
        },
        {
          "record": "DKIM",
          "name": "resend._domainkey",
          "value": "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsc4Lh8xilsngyKEgN2S84+21gn+x6SEXtjWvPiAAmnmggr5FWG42WnqczpzQ/mNblqHz4CDwUum6LtY6SdoOlDmrhvp5khA3cd661W9FlK3yp7+jVACQElS7d9O6jv8VsBbVg4COess3gyLE5RyxqF1vYsrEXqyM8TBz1n5AGkQIDAQA2",
          "type": "TXT",
          "status": "not_started",
          "ttl": "Auto"
        }
      ]
    }
  }
  ```
</ResponseExample>


# domain.deleted
Source: https://resend.com/docs/webhooks/domains/deleted

Received when a domain is deleted.

Event triggered when a **domain was successfully deleted**.

<Info>
  If you're having issues verifying your domain, [review our guide on a domain
  not verifying](/knowledge-base/what-if-my-domain-is-not-verifying) for
  troubleshooting steps.
</Info>

<ResponseBodyParameters type="domain.deleted">
  <ParamField type="string">
    Unique identifier for the domain
  </ParamField>

  <ParamField type="string">
    Domain name (e.g., `example.com`)
  </ParamField>

  <ParamField type="verified | partially_failed | failed | pending | not_started">
    Current verification status of the domain:

    * `verified`: The domain is verified and can be used to send or receive emails.
    * `partially_failed`: The domain is verified but one of the features (send or receive) is not verified.
    * `pending`: The domain is pending verification and cannot be used to send or receive emails.
    * `not_started`: Verification has not started yet, so the domain cannot be used to send or receive emails.
    * `failed`: The domain failed verification.

    <Note>
      The `data.status` field represents an aggregated status of the domain. For
      domains that can both [send](/dashboard/emails/introduction) and
      [receive](/dashboard/receiving/introduction) emails, the status may be
      `partially_failed`, which indicates that one of these features is verified
      while the other is not.
    </Note>
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the domain was created
  </ParamField>

  <ParamField type="us-east-1 | eu-west-1 | sa-east-1 | ap-northeast-1">
    AWS region where the domain is configured.
  </ParamField>

  <ParamField type="array">
    Array of DNS record objects required for domain verification

    <Expandable title="record object">
      <ParamField type="SPF | DKIM | Receiving MX">
        Record type purpose. Learn more about [domain verification records](/dashboard/domains/introduction).
      </ParamField>

      <ParamField type="string">
        DNS record name/subdomain
      </ParamField>

      <ParamField type="MX | TXT | CNAME">
        DNS record type
      </ParamField>

      <ParamField type="string">
        DNS record value to be set
      </ParamField>

      <ParamField type="string">
        Time to live for the DNS record
      </ParamField>

      <ParamField type="string">
        Verification status of this specific record
      </ParamField>

      <ParamField type="number">
        Priority value for MX records (optional)
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "domain.deleted",
    "created_at": "2024-11-17T19:32:22.980Z",
    "data": {
      "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
      "name": "example.com",
      "status": "not_started",
      "created_at": "2024-04-26T20:21:26.347412+00:00",
      "region": "us-east-1",
      "records": [
        {
          "record": "SPF",
          "name": "send",
          "type": "MX",
          "ttl": "Auto",
          "status": "not_started",
          "value": "feedback-smtp.us-east-1.amazonses.com",
          "priority": 10
        },
        {
          "record": "SPF",
          "name": "send",
          "value": "\"v=spf1 include:amazonses.com ~all\"",
          "type": "TXT",
          "ttl": "Auto",
          "status": "not_started"
        },
        {
          "record": "DKIM",
          "name": "resend._domainkey",
          "value": "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsc4Lh8xilsngyKEgN2S84+21gn+x6SEXtjWvPiAAmnmggr5FWG42WnqczpzQ/mNblqHz4CDwUum6LtY6SdoOlDmrhvp5khA3cd661W9FlK3yp7+jVACQElS7d9O6jv8VsBbVg4COess3gyLE5RyxqF1vYsrEXqyM8TBz1n5AGkQIDAQA2",
          "type": "TXT",
          "status": "not_started",
          "ttl": "Auto"
        }
      ]
    }
  }
  ```
</ResponseExample>


# domain.updated
Source: https://resend.com/docs/webhooks/domains/updated

Received when a domain is updated.

Event triggered when a **domain was successfully updated**.

<Info>
  If you're having issues verifying your domain, [review our guide on a domain
  not verifying](/knowledge-base/what-if-my-domain-is-not-verifying) for
  troubleshooting steps.
</Info>

<ResponseBodyParameters type="domain.updated">
  <ParamField type="string">
    Unique identifier for the domain
  </ParamField>

  <ParamField type="string">
    Domain name (e.g., `example.com`)
  </ParamField>

  <ParamField type="verified | partially_failed | failed | pending | not_started">
    Current verification status of the domain:

    * `verified`: The domain is verified and can be used to send or receive emails.
    * `partially_failed`: The domain is verified but one of the features (send or receive) is not verified.
    * `pending`: The domain is pending verification and cannot be used to send or receive emails.
    * `not_started`: Verification has not started yet, so the domain cannot be used to send or receive emails.
    * `failed`: The domain failed verification.

    <Note>
      The `data.status` field represents an aggregated status of the domain. For
      domains that can both [send](/dashboard/emails/introduction) and
      [receive](/dashboard/receiving/introduction) emails, the status may be
      `partially_failed`, which indicates that one of these features is verified
      while the other is not.
    </Note>
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the domain was created
  </ParamField>

  <ParamField type="us-east-1 | eu-west-1 | sa-east-1 | ap-northeast-1">
    AWS region where the domain is configured.
  </ParamField>

  <ParamField type="array">
    Array of DNS record objects required for domain verification

    <Expandable title="record object">
      <ParamField type="SPF | DKIM | Receiving MX">
        Record type purpose. Learn more about [domain verification records](/dashboard/domains/introduction).
      </ParamField>

      <ParamField type="string">
        DNS record name/subdomain
      </ParamField>

      <ParamField type="MX | TXT | CNAME">
        DNS record type
      </ParamField>

      <ParamField type="string">
        DNS record value to be set
      </ParamField>

      <ParamField type="string">
        Time to live for the DNS record
      </ParamField>

      <ParamField type="string">
        Verification status of this specific record
      </ParamField>

      <ParamField type="number">
        Priority value for MX records (optional)
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "domain.updated",
    "created_at": "2024-11-17T19:32:22.980Z",
    "data": {
      "id": "d91cd9bd-1176-453e-8fc1-35364d380206",
      "name": "example.com",
      "status": "not_started",
      "created_at": "2024-04-26T20:21:26.347412+00:00",
      "region": "us-east-1",
      "records": [
        {
          "record": "SPF",
          "name": "send",
          "type": "MX",
          "ttl": "Auto",
          "status": "not_started",
          "value": "feedback-smtp.us-east-1.amazonses.com",
          "priority": 10
        },
        {
          "record": "SPF",
          "name": "send",
          "value": "\"v=spf1 include:amazonses.com ~all\"",
          "type": "TXT",
          "ttl": "Auto",
          "status": "not_started"
        },
        {
          "record": "DKIM",
          "name": "resend._domainkey",
          "value": "p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsc4Lh8xilsngyKEgN2S84+21gn+x6SEXtjWvPiAAmnmggr5FWG42WnqczpzQ/mNblqHz4CDwUum6LtY6SdoOlDmrhvp5khA3cd661W9FlK3yp7+jVACQElS7d9O6jv8VsBbVg4COess3gyLE5RyxqF1vYsrEXqyM8TBz1n5AGkQIDAQA2",
          "type": "TXT",
          "status": "not_started",
          "ttl": "Auto"
        },
        {
          "name": "inbound.yourdomain.tld",
          "priority": 10,
          "record": "Receiving MX",
          "status": "pending",
          "ttl": "Auto",
          "type": "MX",
          "value": "inbound-smtp.us-east-1.amazonaws.com"
        }
      ]
    }
  }
  ```
</ResponseExample>


# email.bounced
Source: https://resend.com/docs/webhooks/emails/bounced

Received when an email bounces.

Event triggered whenever the recipient's mail server **permanently rejected the email**.

<ResponseBodyParameters type="email.bounced">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>

  <ParamField type="object">
    Bounce details from the receiving server

    <Expandable title="bounce object">
      <ParamField type="array">
        Array of SMTP diagnostic responses from the receiving server, including the status code and reason for the bounce (e.g., `smtp; 550 5.5.0 Requested action not taken: mailbox unavailable`)
      </ParamField>

      <ParamField type="string">
        Detailed bounce message from the receiving server
      </ParamField>

      <ParamField type="string">
        Bounce sub-type (e.g., `Suppressed`, `MessageRejected`)
      </ParamField>

      <ParamField type="string">
        Bounce type (e.g., `Permanent`, `Temporary`)
      </ParamField>

      <Info>
        Learn more about [bounce types and subtypes](/dashboard/emails/email-bounces).
      </Info>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.bounced",
    "created_at": "2024-11-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-11-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "bounce": {
        "message": "The recipient's email address is on the suppression list because it has a recent history of producing hard bounces.",
        "subType": "Suppressed",
        "type": "Permanent"
      },
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# email.clicked
Source: https://resend.com/docs/webhooks/emails/clicked

Received when an email link is clicked.

Event triggered whenever the **recipient clicks on an email link**.

<ResponseBodyParameters type="email.clicked">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>

  <ParamField type="object">
    Click tracking details

    <Expandable title="click object">
      <ParamField type="string">
        IP address of the user who clicked the link
      </ParamField>

      <ParamField type="string">
        The URL that was clicked
      </ParamField>

      <ParamField type="string">
        ISO 8601 timestamp when the click occurred
      </ParamField>

      <ParamField type="string">
        User agent string of the browser that clicked the link
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.clicked",
    "created_at": "2024-11-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-11-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "click": {
        "ipAddress": "122.115.53.11",
        "link": "https://resend.com",
        "timestamp": "2024-11-24T05:00:57.163Z",
        "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15"
      },
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# email.complained
Source: https://resend.com/docs/webhooks/emails/complained

Received when an email is marked as spam.

Event triggered whenever the email was successfully **delivered, but the recipient marked it as spam**.

<ResponseBodyParameters type="email.complained">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.complained",
    "created_at": "2024-02-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-02-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# email.delivered
Source: https://resend.com/docs/webhooks/emails/delivered

Received when an email is delivered.

Event triggered whenever Resend **successfully delivered the email** to the recipient's mail server.

<Info>
  Learn more about what to do [when an email is delivered, but the recipient
  does not receive
  it](/knowledge-base/what-if-an-email-says-delivered-but-the-recipient-has-not-received-it).
</Info>

<ResponseBodyParameters type="email.delivered">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.delivered",
    "created_at": "2024-02-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-02-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# email.delivery_delayed
Source: https://resend.com/docs/webhooks/emails/delivery-delayed

Received when an email delivery is delayed.

Event triggered whenever the **email couldn't be delivered due to a temporary issue**.

Delivery delays can occur, for example, when the recipient's inbox is full, or when the receiving email server experiences a transient issue.

<ResponseBodyParameters type="email.delivery_delayed">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.delivery_delayed",
    "created_at": "2024-02-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-02-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# email.failed
Source: https://resend.com/docs/webhooks/emails/failed

Received when an email fails to send.

Event triggered whenever the **email failed to send due to an error**.

This event is triggered when there are issues such as invalid recipients, API key problems, domain verification issues, email quota limits, or other sending failures.

<ResponseBodyParameters type="email.failed">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>

  <ParamField type="object">
    Failure details

    <Expandable title="failed object">
      <ParamField type="string">
        Reason for the email failure (e.g., `reached_daily_quota`)
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.failed",
    "created_at": "2024-11-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-11-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "failed": {
        "reason": "reached_daily_quota"
      },
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# email.opened
Source: https://resend.com/docs/webhooks/emails/opened

Received when an email is opened.

Event triggered whenever the **recipient opened the email**.

<ResponseBodyParameters type="email.opened">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.opened",
    "created_at": "2024-02-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-02-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# email.received
Source: https://resend.com/docs/webhooks/emails/received

Received when an inbound email is received.

Event triggered whenever Resend **successfully receives an email**.

<ResponseBodyParameters type="email.received">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.received",
    "created_at": "2024-02-22T23:41:12.126Z",
    "data": {
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "created_at": "2024-02-22T23:41:11.894719+00:00",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "bcc": [],
      "cc": [],
      "message_id": "<example+123>",
      "subject": "Sending this example",
      "attachments": [
        {
          "id": "2a0c9ce0-3112-4728-976e-47ddcd16a318",
          "filename": "avatar.png",
          "content_type": "image/png",
          "content_disposition": "inline",
          "content_id": "img001"
        }
      ]
    }
  }
  ```
</ResponseExample>


# email.scheduled
Source: https://resend.com/docs/webhooks/emails/scheduled

Received when an email is scheduled to be sent.

Event triggered whenever the **email is scheduled to be sent**.

<ResponseBodyParameters type="email.scheduled">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.scheduled",
    "created_at": "2024-02-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-02-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# email.sent
Source: https://resend.com/docs/webhooks/emails/sent

Received when an email is sent.

Event triggered whenever the **API request was successful**. Resend will attempt to deliver the message to the recipient's mail server.

<ResponseBodyParameters type="email.sent">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.sent",
    "created_at": "2024-02-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-02-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# email.suppressed
Source: https://resend.com/docs/webhooks/emails/suppressed

Received when an email is suppressed.

Event triggered whenever the **email is suppressed** by Resend.

<Info>
  Learn more about [suppressed
  emails](/knowledge-base/why-are-my-emails-landing-on-the-suppression-list).
</Info>

<ResponseBodyParameters type="email.suppressed">
  <ParamField type="string">
    Unique identifier for the broadcast campaign (if applicable)
  </ParamField>

  <ParamField type="string">
    ISO 8601 timestamp when the email was created
  </ParamField>

  <ParamField type="string">
    Unique identifier for the specific email
  </ParamField>

  <ParamField type="string">
    Sender email address and name in the format "Name
    \<[email@domain.com](mailto:email@domain.com)>"
  </ParamField>

  <ParamField type="array">
    Array of impacted recipient email addresses
  </ParamField>

  <ParamField type="string">
    Email subject line
  </ParamField>

  <ParamField type="string">
    Unique identifier for the template used (if applicable)
  </ParamField>

  <ParamField type="array">
    Array of tag objects associated with the email

    <Expandable title="tag object">
      <ParamField type="string">
        The tag key
      </ParamField>

      <ParamField type="string">
        The tag value
      </ParamField>
    </Expandable>
  </ParamField>
</ResponseBodyParameters>

<ResponseExample>
  ```json theme={null}
  {
    "type": "email.suppressed",
    "created_at": "2024-11-22T23:41:12.126Z",
    "data": {
      "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
      "created_at": "2024-11-22T23:41:11.894719+00:00",
      "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
      "from": "Acme <onboarding@resend.dev>",
      "to": ["delivered@resend.dev"],
      "subject": "Sending this example",
      "template_id": "43f68331-0622-4e15-8202-246a0388854b",
      "suppressed": {
        "message": "Resend has suppressed sending to this address because it is on the account-level suppression list. This does not count toward your bounce rate metric",
        "type": "OnAccountSuppressionList"
      },
      "tags": {
        "category": "confirm_email"
      }
    }
  }
  ```
</ResponseExample>


# Event Types
Source: https://resend.com/docs/webhooks/event-types

List of supported event types and their payload.

## Email Events

<div>
  <div>
    <div>
      <span />

      [`email.bounced`](/webhooks/emails/bounced)
    </div>

    <div>
      Occurs whenever the recipient's mail server **permanently rejected the
      email**.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.clicked`](/webhooks/emails/clicked)
    </div>

    <div>
      Occurs whenever the **recipient clicks on an email link**.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.complained`](/webhooks/emails/complained)
    </div>

    <div>
      Occurs whenever the email was successfully **delivered, but the recipient
      marked it as spam**.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.delivered`](/webhooks/emails/delivered)
    </div>

    <div>
      Occurs whenever Resend **successfully delivered the email** to the
      recipient's mail server.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.delivery_delayed`](/webhooks/emails/delivery-delayed)
    </div>

    <div>
      Occurs whenever the **email couldn't be delivered due to a temporary
      issue**. Delivery delays can occur, for example, when the recipient's
      inbox is full, or when the receiving email server experiences a transient
      issue.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.failed`](/webhooks/emails/failed)
    </div>

    <div>
      Occurs whenever the **email failed to send due to an error**. This event
      is triggered when there are issues such as invalid recipients, API key
      problems, domain verification issues, email quota limits, or other sending
      failures.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.opened`](/webhooks/emails/opened)
    </div>

    <div>
      Occurs whenever the **recipient opened the email**.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.received`](/webhooks/emails/received)
    </div>

    <div>
      Occurs whenever Resend **successfully receives an email**.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.scheduled`](/webhooks/emails/scheduled)
    </div>

    <div>
      Occurs whenever the **email is scheduled to be sent**.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.sent`](/webhooks/emails/sent)
    </div>

    <div>
      Occurs whenever the **API request was successful**. Resend will attempt to
      deliver the message to the recipient's mail server.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`email.suppressed`](/webhooks/emails/suppressed)
    </div>

    <div>
      Occurs whenever the **email is suppressed** by Resend.
    </div>
  </div>
</div>

## Domain Events

<div>
  <div>
    <div>
      <span />

      [`domain.created`](/webhooks/domains/created)
    </div>

    <div>
      Occurs when a **domain was successfully created**.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`domain.updated`](/webhooks/domains/updated)
    </div>

    <div>
      Occurs when a **domain was successfully updated**.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`domain.deleted`](/webhooks/domains/deleted)
    </div>

    <div>
      Occurs when a **domain was successfully deleted**.
    </div>
  </div>
</div>

## Contact Events

<div>
  <div>
    <div>
      <span />

      [`contact.created`](/webhooks/contacts/created)
    </div>

    <div>
      Occurs whenever a **contact was successfully created**.
    </div>

    <div>
      *Note: When importing multiple contacts using CSV, these events won't be
      triggered. [Contact support](https://resend.com/contact) if you have any
      questions.*
    </div>
  </div>

  <div>
    <div>
      <span />

      [`contact.updated`](/webhooks/contacts/updated)
    </div>

    <div>
      Occurs whenever a **contact was successfully updated**.
    </div>
  </div>

  <div>
    <div>
      <span />

      [`contact.deleted`](/webhooks/contacts/deleted)
    </div>

    <div>
      Occurs whenever a **contact was successfully deleted**.
    </div>
  </div>
</div>


# Managing Webhooks
Source: https://resend.com/docs/webhooks/introduction

Use webhooks to notify your application about events from Resend.

## What is a webhook?

Resend uses webhooks, which are real-time HTTPS requests that tell your application an event occurred, such as an email delivery notification or subscription status update.

## Why use webhooks?

All webhooks use HTTPS and deliver a JSON payload that can be used by your application. You can use webhook feeds to do things like:

* Automatically remove bounced email addresses from mailing lists
* Create alerts in your messaging or incident tools based on event types
* Store all send events in your own database for custom reporting/retention
* Receive emails using [Inbound](/dashboard/receiving/introduction)

## How to receive webhooks

To receive real-time events in your app via webhooks, follow these steps:

### 1. Create a dev endpoint to receive requests.

In your local application, create a new route that can accept POST requests.

For example, you can add an API route:

```js pages/api/webhooks.ts theme={null}
export default (req, res) => {
  if (req.method === 'POST') {
    const event = req.body;
    console.log(event);
    res.status(200);
  }
};
```

On receiving an event, you should respond with an `HTTP 200 OK` to signal to Resend that the event was successfully delivered.

<Tip>
  For development, you can create a tunnel to your localhost server using a tool like
  [ngrok](https://ngrok.com/download) or [VS Code Port Forwarding](https://code.visualstudio.com/docs/debugtest/port-forwarding). These tools serve your local dev environment at a public URL you can use to test your local webhook endpoint.

  Example: `https://example123.ngrok.io/api/webhook`
</Tip>

### 2. Add a webhook in Resend.

Navigate to the [Webhooks page](https://resend.com/webhooks) select **Add Webhook**.

1. Add your your publicly accessible HTTPS URL
2. Select all events you want to observe

<img alt="Add Webhook" />

<Info>
  Resend also supports managing webhooks via the API or the SDKs. View the [API reference](/api-reference/webhooks/create-webhook) for more details.
</Info>

### 3. Test your local endpoint.

To ensure your endpoint is successfully receiving events, perform an event you are tracking with your webhook, like sending an email, creating a contact, or creating a domain.

The webhook will send a JSON payload to your endpoint with the event details. For example:

```json theme={null}
{
  "type": "email.bounced",
  "created_at": "2024-11-22T23:41:12.126Z",
  "data": {
    "broadcast_id": "8b146471-e88e-4322-86af-016cd36fd216",
    "created_at": "2024-11-22T23:41:11.894719+00:00",
    "email_id": "56761188-7520-42d8-8898-ff6fc54ce618",
    "from": "Acme <onboarding@resend.dev>",
    "to": ["delivered@resend.dev"],
    "subject": "Sending this example",
    "template_id": "43f68331-0622-4e15-8202-246a0388854b",
    "bounce": {
      "message": "The recipient's email address is on the suppression list because it has a recent history of producing hard bounces.",
      "subType": "Suppressed",
      "type": "Permanent"
    },
    "tags": {
      "category": "confirm_email"
    }
  }
}
```

You can also see the webhook details in the dashboard.

<img alt="Webhook Events List" />

<Info>
  View all possible [event types and their webhook payload
  responses](/webhooks/event-types).
</Info>

### 4. Update and deploy your production endpoint.

Once you successfully receive events, update your endpoint to process the events.

For example, update your API route:

```js pages/api/webhooks.ts theme={null}

export default (req:, res) => {
  if (req.method === 'POST') {
    const event = req.body;
    if(event.type === "email.bounced"){
      //
    }
    res.status(200);
  }
};
```

After you're done testing, deploy your webhook endpoint to production.

### 4. Register your production webhook endpoint

Once your webhook endpoint is deployed to production, you can register it in the Resend dashboard.

## FAQ

<AccordionGroup>
  <Accordion title="What is the retry schedule?">
    If Resend does not receive a 200 response from a webhook server, we will retry the webhooks.

    Each message is attempted based on the following schedule, where each period is started following the failure of the preceding attempt:

    * 5 seconds
    * 5 minutes
    * 30 minutes
    * 2 hours
    * 5 hours
    * 10 hours

    You can see when a message will be retried next in the webhook message details in the dashboard.
  </Accordion>

  <Accordion title="What IPs do webhooks POST from?">
    If your server requires an allowlist, our webhooks come from the following IP addresses:

    * `44.228.126.217`
    * `50.112.21.217`
    * `52.24.126.164`
    * `54.148.139.208`
    * `2600:1f24:64:8000::/52`
  </Accordion>

  <Accordion title="Can I retry webhook events manually?">
    Yes. You can retry webhook events manually from the dashboard.

    To retry a webhook event, click to see your webhook details
    and then click the link to the event you want to retry.

    On that page, you will see both the payload for the event
    and a button to replay the webhook event and get it sent to
    the configured webhook endpoint.
  </Accordion>
</AccordionGroup>

## Try it yourself

<Card title="Webhook Code Example" icon="arrow-up-right-from-square" href="https://github.com/resend/resend-examples/tree/main/with-webhooks">
  See an example of how to receive webhooks events for Resend emails.
</Card>


# Retries and Replays
Source: https://resend.com/docs/webhooks/retries-and-replays

Learn how to use the retries and replays to handle webhook failures.

## Automatic Retries

We attempt to deliver each webhook message based on a schedule with exponential backoff.

Each message is attempted based on the following schedule, where each period is started following the failure of the preceding attempt:

* Immediately
* 5 seconds
* 5 minutes
* 30 minutes
* 2 hours
* 5 hours
* 10 hours
* 10 hours (in addition to the previous)

If an endpoint is removed or disabled delivery attempts to the endpoint will be disabled as well.

To see when a message will be retried next, check the webhook message details in the dashboard.

For example, an attempt that fails three times before eventually succeeding will be delivered roughly 35 minutes and 5 seconds following the first attempt.

## Manual Replays

If a webhook message fails, you can manually replay it.

You can replay both `failed` and `succeeded` webhook messages.

<img alt="Replay Webhook" />

Here's how to replay a webhook message:

1. Go to the [Webhooks](https://resend.com/webhooks) page
2. Navigate to the Webhook Endpoint you are using
3. Go to the Webhook Message you want to replay
4. Click on the "Replay" button


# Verify Webhooks Requests
Source: https://resend.com/docs/webhooks/verify-webhooks-requests

Learn how to use the signing secret to verify your webhooks.

Webhook signing secrets are used to validate the payload data sent to your application from Resend. You can find the signing secret on the webhook details page.

<img alt="Signing Secret" />

Calls to [create](/api-reference/webhooks/create-webhook), [retrieve](/api-reference/webhooks/get-webhook), or [list](/api-reference/webhooks/list-webhooks) webhooks will also return the signing secret in the response body.

To verify the webhook request, you can use the Resend SDK, as in the example below.

<Tip>
  Make sure that you're using the raw request body when verifying webhooks. The
  cryptographic signature is sensitive to even the slightest change. Some
  frameworks parse the request as JSON and then stringify it, and this will also
  break the signature verification.
</Tip>

```js theme={null}
export async function POST(req: NextRequest) {
  try {
    const payload = await req.text();

    // Throws an error if the webhook is invalid
    // Otherwise, returns the parsed payload object
    const result = resend.webhooks.verify({
      payload,
      headers: {
        id: req.headers['svix-id'],
        timestamp: req.headers['svix-timestamp'],
        signature: req.headers['svix-signature'],
      },
      webhookSecret: process.env.RESEND_WEBHOOK_SECRET,
    });

    // Handle the result after validating it
  } catch {
    return new NextResponse('Invalid webhook', { status: 400 });
  }
}
```

Alternatively, you can manually use the Svix libraries and manually pass it the headers, body, and webhook secret. [Learn more and view all supported languages here.](https://docs.svix.com/receiving/verifying-payloads/how)

To verify manually, start by installing the Svix libaries.

<CodeGroup>
  ```sh npm theme={null}
  npm install svix
  ```

  ```sh yarn theme={null}
  yarn add svix
  ```

  ```sh pnpm theme={null}
  pnpm add svix
  ```

  ```sh bun theme={null}
  bun add svix
  ```
</CodeGroup>

Then, verify the webhooks using the code below. The payload is the raw (string) body of the request, and the headers are the headers passed in the request.

```js theme={null}
import { Webhook } from 'svix';

const secret = process.env.WEBHOOK_SECRET;

// These were all sent from the server
const headers = {
  'svix-id': 'msg_p5jXN8AQM9LWM0D4loKWxJek',
  'svix-timestamp': '1614265330',
  'svix-signature': 'v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=',
};
const payload = '{"test": 2432232314}';

const wh = new Webhook(secret);
// Throws on error, returns the verified content on success
wh.verify(payload, headers);
```

If you prefer, you can also [manually verify the headers as well.](https://docs.svix.com/receiving/verifying-payloads/how-manual)

## Why should I verify webhooks?

Webhooks are vulnerable because attackers can send fake HTTP POST requests to endpoints, pretending to be legitimate services. This can lead to security risks or operational issues.

To mitigate this, each webhook and its metadata are signed with a unique key specific to the endpoint. This signature helps verify the source of the webhook, allowing only authenticated webhooks to be processed.

Another security concern is replay attacks, where intercepted valid payloads, complete with their signatures, are resent to endpoints. These payloads would pass the signature verification and be executed, posing a potential security threat.