How to Send Emails in Java / Spring Boot (2026 Guide)

<!-- Spring WebClient for HTTP calls -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

<!-- Thymeleaf for email templates -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

<!-- Resend Java SDK -->
<dependency>
  <groupId>com.resend</groupId>
  <artifactId>resend-java</artifactId>
  <version>3.1.0</version>
</dependency>

<!-- Thymeleaf for email templates -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

<!-- SendGrid Java SDK -->
<dependency>
  <groupId>com.sendgrid</groupId>
  <artifactId>sendgrid-java</artifactId>
  <version>4.10.2</version>
</dependency>

<!-- Thymeleaf for email templates -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

email.provider=sequenzy
email.api-key=${SEQUENZY_API_KEY}
email.from-address=noreply@yourdomain.com
email.from-name=Your App

email.provider=resend
email.api-key=${RESEND_API_KEY}
email.from-address=noreply@yourdomain.com
email.from-name=Your App

email.provider=sendgrid
email.api-key=${SENDGRID_API_KEY}
email.from-address=noreply@yourdomain.com
email.from-name=Your App

package com.example.service;

import com.example.config.EmailProperties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.reactive.function.client.WebClientResponseException;

import java.util.Map;

@Service
public class SequenzyEmailService implements EmailService {

  private static final Logger log = LoggerFactory.getLogger(SequenzyEmailService.class);
  private final WebClient webClient;

  public SequenzyEmailService(EmailProperties props) {
      this.webClient = WebClient.builder()
          .baseUrl("https://api.sequenzy.com/v1")
          .defaultHeader("Authorization", "Bearer " + props.apiKey())
          .defaultHeader("Content-Type", "application/json")
          .build();
  }

  @Override
  public EmailResult send(String to, String subject, String body) {
      try {
          @SuppressWarnings("unchecked")
          Map<String, Object> response = webClient.post()
              .uri("/transactional/send")
              .bodyValue(Map.of("to", to, "subject", subject, "body", body))
              .retrieve()
              .bodyToMono(Map.class)
              .block();

          String jobId = response != null ? String.valueOf(response.get("jobId")) : null;
          log.info("Email sent to {}, subject: {}, jobId: {}", to, subject, jobId);
          return EmailResult.ok(jobId);

      } catch (WebClientResponseException.TooManyRequests e) {
          log.warn("Rate limited sending email to {}", to);
          return EmailResult.fail("Rate limited");

      } catch (WebClientResponseException.Unauthorized e) {
          log.error("Invalid API key for email send");
          return EmailResult.fail("Invalid API key");

      } catch (WebClientResponseException e) {
          log.error("Email send failed ({}) to {}: {}", e.getStatusCode(), to, e.getResponseBodyAsString());
          return EmailResult.fail(e.getMessage());

      } catch (Exception e) {
          log.error("Email send failed to {}: {}", to, e.getMessage());
          return EmailResult.fail(e.getMessage());
      }
  }
}

package com.example.service;

import com.example.config.EmailProperties;
import com.resend.Resend;
import com.resend.core.exception.ResendException;
import com.resend.services.emails.model.CreateEmailOptions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

@Service
public class ResendEmailService implements EmailService {

  private static final Logger log = LoggerFactory.getLogger(ResendEmailService.class);
  private final Resend resend;
  private final String from;

  public ResendEmailService(EmailProperties props) {
      this.resend = new Resend(props.apiKey());
      this.from = props.fromFormatted();
  }

  @Override
  public EmailResult send(String to, String subject, String html) {
      try {
          var params = CreateEmailOptions.builder()
              .from(from)
              .to(to)
              .subject(subject)
              .html(html)
              .build();

          var response = resend.emails().send(params);
          log.info("Email sent to {}, id: {}", to, response.getId());
          return EmailResult.ok(response.getId());

      } catch (ResendException e) {
          log.error("Email send failed to {}: {}", to, e.getMessage());
          return EmailResult.fail(e.getMessage());
      }
  }
}

package com.example.service;

import com.example.config.EmailProperties;
import com.sendgrid.*;
import com.sendgrid.helpers.mail.Mail;
import com.sendgrid.helpers.mail.objects.Content;
import com.sendgrid.helpers.mail.objects.Email;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.io.IOException;

@Service
public class SendGridEmailService implements EmailService {

  private static final Logger log = LoggerFactory.getLogger(SendGridEmailService.class);
  private final SendGrid sg;
  private final String fromAddress;

  public SendGridEmailService(EmailProperties props) {
      this.sg = new SendGrid(props.apiKey());
      this.fromAddress = props.fromAddress();
  }

  @Override
  public EmailResult send(String to, String subject, String html) {
      try {
          var from = new Email(fromAddress);
          var toEmail = new Email(to);
          var content = new Content("text/html", html);
          var mail = new Mail(from, subject, toEmail, content);

          var request = new Request();
          request.setMethod(Method.POST);
          request.setEndpoint("mail/send");
          request.setBody(mail.build());

          var response = sg.api(request);

          if (response.getStatusCode() >= 400) {
              log.error("SendGrid error ({}) for {}: {}", response.getStatusCode(), to, response.getBody());
              return EmailResult.fail("SendGrid error: " + response.getStatusCode());
          }

          log.info("Email sent to {} via SendGrid", to);
          return EmailResult.ok(null);

      } catch (IOException e) {
          log.error("Email send failed to {}: {}", to, e.getMessage());
          return EmailResult.fail(e.getMessage());
      }
  }
}

package com.example.controller;

import com.example.service.EmailService;
import com.example.service.EmailTemplateService;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Map;

@RestController
@RequestMapping("/webhooks/stripe")
public class StripeWebhookController {

  private static final Logger log = LoggerFactory.getLogger(StripeWebhookController.class);

  private final EmailService emailService;
  private final EmailTemplateService templateService;
  private final String webhookSecret;
  private final ObjectMapper objectMapper;

  public StripeWebhookController(
          EmailService emailService,
          EmailTemplateService templateService,
          @Value("${stripe.webhook-secret}") String webhookSecret,
          ObjectMapper objectMapper) {
      this.emailService = emailService;
      this.templateService = templateService;
      this.webhookSecret = webhookSecret;
      this.objectMapper = objectMapper;
  }

  @PostMapping
  public ResponseEntity<Map<String, Boolean>> handle(
          @RequestBody String payload,
          @RequestHeader("Stripe-Signature") String sigHeader) {

      if (!verifySignature(payload, sigHeader)) {
          return ResponseEntity.badRequest().build();
      }

      try {
          JsonNode event = objectMapper.readTree(payload);
          String eventType = event.get("type").asText();
          JsonNode data = event.get("data").get("object");

          switch (eventType) {
              case "checkout.session.completed" -> handleCheckout(data);
              case "invoice.payment_failed" -> handlePaymentFailed(data);
          }

      } catch (Exception e) {
          log.error("Webhook processing error: {}", e.getMessage());
      }

      return ResponseEntity.ok(Map.of("received", true));
  }

  private void handleCheckout(JsonNode session) {
      String email = session.get("customer_email").asText();
      int amount = session.get("amount_total").asInt();
      String formatted = "$%.2f".formatted(amount / 100.0);

      String html = templateService.render("receipt", Map.of(
          "amount", formatted, "plan", "Pro", "invoiceUrl", "#"
      ));

      emailService.send(email, "Payment receipt - " + formatted, html);
      log.info("Checkout completed for {}", email);
  }

  private void handlePaymentFailed(JsonNode invoice) {
      String email = invoice.get("customer_email").asText();
      emailService.send(email, "Payment failed",
          "<h1>Payment issue</h1><p>We couldn't process your payment. Please update your card.</p>");
      log.warn("Payment failed for {}", email);
  }

  private boolean verifySignature(String payload, String sigHeader) {
      try {
          Map<String, String> parts = new java.util.HashMap<>();
          for (String part : sigHeader.split(",")) {
              String[] kv = part.split("=", 2);
              parts.put(kv[0], kv[1]);
          }

          String timestamp = parts.get("t");
          String signature = parts.get("v1");
          String signedPayload = timestamp + "." + payload;

          Mac mac = Mac.getInstance("HmacSHA256");
          mac.init(new SecretKeySpec(webhookSecret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
          byte[] hash = mac.doFinal(signedPayload.getBytes(StandardCharsets.UTF_8));
          String expected = bytesToHex(hash);

          return MessageDigest.isEqual(expected.getBytes(), signature.getBytes());
      } catch (Exception e) {
          log.error("Signature verification failed: {}", e.getMessage());
          return false;
      }
  }

  private static String bytesToHex(byte[] bytes) {
      StringBuilder sb = new StringBuilder();
      for (byte b : bytes) sb.append("%02x".formatted(b));
      return sb.toString();
  }
}

package com.example.controller;

import com.example.service.EmailService;
import com.example.service.EmailTemplateService;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Map;

@RestController
@RequestMapping("/webhooks/stripe")
public class StripeWebhookController {

  private static final Logger log = LoggerFactory.getLogger(StripeWebhookController.class);
  private final EmailService emailService;
  private final EmailTemplateService templateService;
  private final String webhookSecret;
  private final ObjectMapper objectMapper;

  public StripeWebhookController(EmailService emailService, EmailTemplateService templateService,
          @Value("${stripe.webhook-secret}") String webhookSecret, ObjectMapper objectMapper) {
      this.emailService = emailService;
      this.templateService = templateService;
      this.webhookSecret = webhookSecret;
      this.objectMapper = objectMapper;
  }

  @PostMapping
  public ResponseEntity<Map<String, Boolean>> handle(
          @RequestBody String payload,
          @RequestHeader("Stripe-Signature") String sigHeader) {

      if (!verifySignature(payload, sigHeader)) {
          return ResponseEntity.badRequest().build();
      }

      try {
          JsonNode event = objectMapper.readTree(payload);
          String eventType = event.get("type").asText();
          JsonNode data = event.get("data").get("object");

          switch (eventType) {
              case "checkout.session.completed" -> {
                  String email = data.get("customer_email").asText();
                  int amount = data.get("amount_total").asInt();
                  String formatted = "$%.2f".formatted(amount / 100.0);
                  String html = templateService.render("receipt", Map.of(
                      "amount", formatted, "plan", "Pro", "invoiceUrl", "#"));
                  emailService.send(email, "Payment receipt - " + formatted, html);
              }
              case "invoice.payment_failed" -> {
                  String email = data.get("customer_email").asText();
                  emailService.send(email, "Payment failed",
                      "<h1>Payment issue</h1><p>Please update your payment method.</p>");
              }
          }
      } catch (Exception e) {
          log.error("Webhook error: {}", e.getMessage());
      }

      return ResponseEntity.ok(Map.of("received", true));
  }

  private boolean verifySignature(String payload, String sigHeader) {
      try {
          Map<String, String> parts = new java.util.HashMap<>();
          for (String part : sigHeader.split(",")) {
              String[] kv = part.split("=", 2);
              parts.put(kv[0], kv[1]);
          }
          String signedPayload = parts.get("t") + "." + payload;
          Mac mac = Mac.getInstance("HmacSHA256");
          mac.init(new SecretKeySpec(webhookSecret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
          String expected = bytesToHex(mac.doFinal(signedPayload.getBytes(StandardCharsets.UTF_8)));
          return MessageDigest.isEqual(expected.getBytes(), parts.get("v1").getBytes());
      } catch (Exception e) { return false; }
  }

  private static String bytesToHex(byte[] bytes) {
      StringBuilder sb = new StringBuilder();
      for (byte b : bytes) sb.append("%02x".formatted(b));
      return sb.toString();
  }
}

package com.example.controller;

import com.example.service.EmailService;
import com.example.service.EmailTemplateService;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.Map;

@RestController
@RequestMapping("/webhooks/stripe")
public class StripeWebhookController {

  private static final Logger log = LoggerFactory.getLogger(StripeWebhookController.class);
  private final EmailService emailService;
  private final EmailTemplateService templateService;
  private final String webhookSecret;
  private final ObjectMapper objectMapper;

  public StripeWebhookController(EmailService emailService, EmailTemplateService templateService,
          @Value("${stripe.webhook-secret}") String webhookSecret, ObjectMapper objectMapper) {
      this.emailService = emailService;
      this.templateService = templateService;
      this.webhookSecret = webhookSecret;
      this.objectMapper = objectMapper;
  }

  @PostMapping
  public ResponseEntity<Map<String, Boolean>> handle(
          @RequestBody String payload,
          @RequestHeader("Stripe-Signature") String sigHeader) {

      if (!verifySignature(payload, sigHeader)) {
          return ResponseEntity.badRequest().build();
      }

      try {
          JsonNode event = objectMapper.readTree(payload);
          String eventType = event.get("type").asText();
          JsonNode data = event.get("data").get("object");

          switch (eventType) {
              case "checkout.session.completed" -> {
                  String email = data.get("customer_email").asText();
                  int amount = data.get("amount_total").asInt();
                  String formatted = "$%.2f".formatted(amount / 100.0);
                  String html = templateService.render("receipt", Map.of(
                      "amount", formatted, "plan", "Pro", "invoiceUrl", "#"));
                  emailService.send(email, "Payment receipt - " + formatted, html);
              }
              case "invoice.payment_failed" -> {
                  String email = data.get("customer_email").asText();
                  emailService.send(email, "Payment failed",
                      "<h1>Payment issue</h1><p>Please update your payment method.</p>");
              }
          }
      } catch (Exception e) {
          log.error("Webhook error: {}", e.getMessage());
      }

      return ResponseEntity.ok(Map.of("received", true));
  }

  private boolean verifySignature(String payload, String sigHeader) {
      try {
          Map<String, String> parts = new java.util.HashMap<>();
          for (String part : sigHeader.split(",")) {
              String[] kv = part.split("=", 2);
              parts.put(kv[0], kv[1]);
          }
          String signedPayload = parts.get("t") + "." + payload;
          Mac mac = Mac.getInstance("HmacSHA256");
          mac.init(new SecretKeySpec(webhookSecret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"));
          String expected = bytesToHex(mac.doFinal(signedPayload.getBytes(StandardCharsets.UTF_8)));
          return MessageDigest.isEqual(expected.getBytes(), parts.get("v1").getBytes());
      } catch (Exception e) { return false; }
  }

  private static String bytesToHex(byte[] bytes) {
      StringBuilder sb = new StringBuilder();
      for (byte b : bytes) sb.append("%02x".formatted(b));
      return sb.toString();
  }
}