Resend Go SDK

To install the Resend Go SDK in your Go project, run the following command in your terminal:

go get github.com/resend/resend-go/v4

When creating or updating a template, any variable used in the HTML content (e.g., {{{NAME}}}) must be explicitly declared in the Variables array. Failure to declare a variable used in the HTML will result in an API validation error.

TemplateVariable fields:

• Key: The name of the variable (e.g., NAME).
• Type: The VariableType (VariableTypeString or VariableTypeNumber).
• FallbackValue: An optional value to use if the variable is not provided during email sending.

params := &resend.CreateTemplateRequest{
    Name: "My Template",
    Html: "<div>Hello {{{USER_NAME}}}!</div>",
    Variables: []*resend.TemplateVariable{
        {
            Key:           "USER_NAME",
            Type:          resend.VariableTypeString,
            FallbackValue: "Guest",
        },
    },
}

Suppressions in Resend are categorized by their SuppressionOrigin. This helps identify why an email address was added to the list.

Available Origins:

• SuppressionOriginBounce ("bounce"): The email bounced.
• SuppressionOriginComplaint ("complaint"): The recipient marked the email as spam.
• SuppressionOriginManual ("manual"): The suppression was added manually via the API.

Data Structures:

• SuppressionListEntry: Used in List responses. It does not contain an Object field.
• Suppression: Used in Get responses. Includes the Object field.
• SourceId: A pointer to a string that identifies the specific event (like a bounce event ID) that caused the suppression. This is nil for manual suppressions.

When sending batches of emails, you can control how the API handles invalid email requests using BatchValidationMode.

• BatchValidationStrict: The default mode. The entire batch is only sent if all emails in the request are valid. If any email is invalid, the whole batch fails.
• BatchValidationPermissive: Allows partial success. The API will process all valid emails in the batch and return a list of specific errors for the invalid ones.

// Use BatchValidationPermissive to allow some emails to succeed even if others fail
options := &resend.BatchSendEmailOptions{
    BatchValidation: resend.BatchValidationPermissive,
}

The Audiences API is deprecated and has been renamed to Segments. While the AudiencesSvc and its associated types are maintained for backward compatibility, they internally call the Segments API. For all new development, you should use the SegmentsSvc and its corresponding types to ensure long-term compatibility and access to the latest features.

Mapping of deprecated types to new types:

• AudiencesSvc $\rightarrow$ SegmentsSvc
• AudiencesSvcImpl $\rightarrow$ SegmentsSvcImpl
• CreateAudienceRequest $\rightarrow$ CreateSegmentRequest
• CreateAudienceResponse $\rightarrow$ CreateSegmentResponse
• RemoveAudienceResponse $\rightarrow$ RemoveSegmentResponse
• ListAudiencesResponse $\rightarrow$ ListSegmentsResponse
• Audience $\rightarrow$ Segment

To interact with the Resend API, you must first create a Client. You can use the standard constructor NewClient which uses a default HTTP client, or NewCustomClient if you need to provide your own *http.Client (e.g., for custom timeouts or proxy settings).

Note that the client uses the RESEND_BASE_URL environment variable if you need to point to a different base URL, defaulting to https://api.resend.com/.

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

// Using the default constructor
client := resend.NewClient("re_123456789")

// Using a custom HTTP client
customHTTPClient := &http.Client{
    Timeout: 30 * time.Second,
}
client := resend.NewCustomClient(customHTTPClient, "re_123456789")

When running the application via Docker Compose, you must provide your Resend API key using the RESEND_API_KEY environment variable. This value is injected into the app service.

environment:
  RESEND_API_KEY: ${RESEND_API_KEY}

The DomainClaimsSvc interface provides methods to claim a domain that has already been verified by another Resend account. This process allows you to take ownership of a domain within Resend.

Key operations include:

• Create: Starts a new claim process.
• Get: Retrieves the current status and DNS records for a specific claim.
• Verify: Triggers the asynchronous DNS verification and ownership transfer process.

Most methods have a WithContext variant for better control over request lifecycles in Go applications.

// Example usage pattern
claim, err := domainClaimsSvc.Create(ctx, &resend.CreateDomainClaimRequest{
    Name: "example.com",
})

// Trigger verification
verifiedClaim, err := domainClaimsSvc.Verify(domainId)

// Poll for status
status, err := domainClaimsSvc.Get(domainId)
if status.Status == resend.DomainClaimStatusCompleted {
    // Claim successful
}