diff --git a/includes/payment-methods/class-wc-stripe-upe-payment-method-sepa.php b/includes/payment-methods/class-wc-stripe-upe-payment-method-sepa.php
new file mode 100644
index 0000000..a8dd752
--- /dev/null
+++ b/includes/payment-methods/class-wc-stripe-upe-payment-method-sepa.php
@@ -0,0 +1,40 @@
+<?php
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+/**
+ * SEPA Payment Method class extending UPE base class
+ */
+class WC_Stripe_UPE_Payment_Method_Sepa extends WC_Stripe_UPE_Payment_Method {
+
+	const STRIPE_ID = 'sepa_debit';
+
+	const LPM_GATEWAY_CLASS = WC_Gateway_Stripe_Sepa::class;
+
+	/**
+	 * Constructor for SEPA payment method
+	 *
+	 * @param WC_Payments_Token_Service $token_service Token class instance.
+	 */
+	public function __construct() {
+		parent::__construct();
+		$this->stripe_id            = self::STRIPE_ID;
+		$this->title                = __( 'Pay with SEPA Direct Debit', 'woocommerce-gateway-stripe' );
+		$this->is_reusable          = true;
+		$this->supported_currencies = [ 'EUR' ];
+		$this->label                = __( 'SEPA Direct Debit', 'woocommerce-gateway-stripe' );
+		$this->description          = __(
+			'Reach 500 million customers and over 20 million businesses across the European Union.',
+			'woocommerce-gateway-stripe'
+		);
+	}
+
+	/**
+	 * Returns string representing payment method type
+	 * to query to retrieve saved payment methods from Stripe.
+	 */
+	public function get_retrievable_type() {
+		return $this->get_id();
+	}
+}
