diff --git a/templates/emails/failed-preorder-authentication.php b/templates/emails/failed-preorder-authentication.php
new file mode 100644
index 0000000..f1d6a00
--- /dev/null
+++ b/templates/emails/failed-preorder-authentication.php
@@ -0,0 +1,64 @@
+<?php
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly
+}
+?>
+
+<?php do_action( 'woocommerce_email_header', $email_heading, $email ); ?>
+
+<?php
+$billing_email = $order->get_billing_email();
+$billing_phone = $order->get_billing_phone();
+
+?>
+<p>
+<?php
+	echo wp_kses(
+		sprintf(
+			// translators: 1) is a link to the payment re-authentication URL.
+			_x( 'Your pre-order is now available, but payment cannot be completed automatically. %1$s', 'In failed SCA authentication for a pre-order.', 'woocommerce-gateway-stripe' ),
+			'<a href="' . esc_url( $authorization_url ) . '">' . esc_html__( 'Authorize the payment now &raquo;', 'woocommerce-gateway-stripe' ) . '</a>'
+		),
+		[ 'a' => [ 'href' => true ] ]
+	);
+	?>
+	</p>
+
+<?php if ( $email->get_custom_message() ) : ?>
+	<blockquote><?php echo wpautop( wptexturize( $email->get_custom_message() ) ); ?></blockquote>
+<?php endif; ?>
+
+<?php
+do_action( 'woocommerce_email_before_order_table', $order, false, $plain_text, $email );
+
+/*
+ * @hooked WC_Emails::order_details() Shows the order details table.
+ * @hooked WC_Structured_Data::generate_order_data() Generates structured data.
+ * @hooked WC_Structured_Data::output_structured_data() Outputs structured data.
+ * @since 2.5.0
+ */
+do_action( 'woocommerce_email_order_details', $order, $sent_to_admin, $plain_text, $email );
+
+/*
+ * @hooked WC_Emails::order_meta() Shows order meta data.
+ */
+do_action( 'woocommerce_email_order_meta', $order, $sent_to_admin, $plain_text, $email );
+
+do_action( 'woocommerce_email_after_order_table', $order, false, $plain_text, $email );
+
+/*
+ * @hooked WC_Emails::customer_details() Shows customer details
+ * @hooked WC_Emails::email_address() Shows email address
+ */
+do_action( 'woocommerce_email_customer_details', $order, $sent_to_admin, $plain_text, $email );
+
+?>
+<p>
+<?php esc_html_e( 'Thanks for shopping with us.', 'woocommerce-gateway-stripe' ); ?>
+</p>
+<?php
+
+/*
+ * @hooked WC_Emails::email_footer() Output the email footer
+ */
+do_action( 'woocommerce_email_footer', $email );
diff --git a/templates/emails/failed-renewal-authentication-requested.php b/templates/emails/failed-renewal-authentication-requested.php
new file mode 100644
index 0000000..ad221a7
--- /dev/null
+++ b/templates/emails/failed-renewal-authentication-requested.php
@@ -0,0 +1,57 @@
+<?php
+/**
+ * Admin email about payment retry failed due to authentication
+ *
+ * @package WooCommerce_Stripe/Templates/Emails
+ * @version 4.3.0
+ */
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+/**
+ * Output the email header.
+ */
+do_action( 'woocommerce_email_header', $email_heading, $email ); ?>
+
+<p>
+	<?php
+	echo esc_html(
+		sprintf(
+			// translators: 1) an order number, 2) the customer's full name, 3) lowercase human time diff in the form returned by wcs_get_human_time_diff(), e.g. 'in 12 hours'.
+			_x(
+				'The automatic recurring payment for order %1$s from %2$s has failed. The customer was sent an email requesting authentication of payment. If the customer does not authenticate the payment, they will be requested by email again %3$s.',
+				'In admin renewal failed email',
+				'woocommerce-gateway-stripe'
+			),
+			$order->get_order_number(),
+			$order->get_formatted_billing_full_name(),
+			wcs_get_human_time_diff( $retry->get_time() )
+		)
+	);
+	?>
+</p>
+<p><?php esc_html_e( 'The renewal order is as follows:', 'woocommerce-gateway-stripe' ); ?></p>
+
+<?php
+
+/**
+ * Shows the order details table.
+ */
+do_action( 'woocommerce_email_order_details', $order, $sent_to_admin, $plain_text, $email );
+
+/**
+* Shows order meta data.
+*/
+do_action( 'woocommerce_email_order_meta', $order, $sent_to_admin, $plain_text, $email );
+
+/**
+* Shows customer details, and email address.
+*/
+do_action( 'woocommerce_email_customer_details', $order, $sent_to_admin, $plain_text, $email );
+
+/**
+* Output the email footer.
+*/
+do_action( 'woocommerce_email_footer', $email );
diff --git a/templates/emails/failed-renewal-authentication.php b/templates/emails/failed-renewal-authentication.php
new file mode 100644
index 0000000..4ab62b4
--- /dev/null
+++ b/templates/emails/failed-renewal-authentication.php
@@ -0,0 +1,18 @@
+<?php
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly
+}
+?>
+
+<?php do_action( 'woocommerce_email_header', $email_heading, $email ); ?>
+
+<p>
+	<?php
+	// translators: 1) name of the blog, 2) link to payment re-authentication URL, note: no full stop due to url at the end
+	echo wp_kses( sprintf( _x( 'The automatic payment to renew your subscription with %1$s has failed. To reactivate the subscription, please login and authorize the renewal from your account page: %2$s', 'In failed renewal authentication email', 'woocommerce-gateway-stripe' ), esc_html( get_bloginfo( 'name' ) ), '<a href="' . esc_url( $authorization_url ) . '">' . esc_html__( 'Authorize the payment &raquo;', 'woocommerce-gateway-stripe' ) . '</a>' ), [ 'a' => [ 'href' => true ] ] );
+	?>
+</p>
+
+<?php do_action( 'woocommerce_subscriptions_email_order_details', $order, $sent_to_admin, $plain_text, $email ); ?>
+
+<?php do_action( 'woocommerce_email_footer', $email ); ?>
diff --git a/templates/emails/index.html b/templates/emails/index.html
new file mode 100644
index 0000000..be228f3
--- /dev/null
+++ b/templates/emails/index.html
@@ -0,0 +1,12 @@
+<html><head><title> - Revision 2844313: /woocommerce-gateway-stripe/trunk/templates/emails</title></head>
+<body>
+ <h2> - Revision 2844313: /woocommerce-gateway-stripe/trunk/templates/emails</h2>
+ <ul>
+  <li><a href="../">..</a></li>
+  <li><a href="failed-preorder-authentication.php">failed-preorder-authentication.php</a></li>
+  <li><a href="failed-renewal-authentication-requested.php">failed-renewal-authentication-requested.php</a></li>
+  <li><a href="failed-renewal-authentication.php">failed-renewal-authentication.php</a></li>
+  <li><a href="plain/">plain/</a></li>
+ </ul>
+ <hr noshade><em>Powered by <a href="http://subversion.apache.org/">Apache Subversion</a> version 1.9.5 (r1770682).</em>
+</body></html>
\ No newline at end of file
diff --git a/templates/emails/plain/failed-preorder-authentication.php b/templates/emails/plain/failed-preorder-authentication.php
new file mode 100644
index 0000000..6bbf4a2
--- /dev/null
+++ b/templates/emails/plain/failed-preorder-authentication.php
@@ -0,0 +1,29 @@
+<?php
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly
+}
+
+echo $email_heading . "\n\n";
+
+printf(
+	// translators: 1) is a link to the payment re-authentication URL.
+	__( 'Your pre-order is now available, but payment cannot be completed automatically. Please complete the payment now: %1$s', 'woocommerce-gateway-stripe' ),
+	$authorization_url
+);
+
+if ( $email->get_custom_message() ) :
+
+	echo "----------\n\n";
+	echo wptexturize( $email->get_custom_message() ) . "\n\n";
+	echo "----------\n\n";
+
+endif;
+
+
+echo "\n\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n";
+
+do_action( 'woocommerce_subscriptions_email_order_details', $order, $sent_to_admin, $plain_text, $email );
+
+echo "\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n";
+
+echo apply_filters( 'woocommerce_email_footer_text', get_option( 'woocommerce_email_footer_text' ) );
diff --git a/templates/emails/plain/failed-renewal-authentication-requested.php b/templates/emails/plain/failed-renewal-authentication-requested.php
new file mode 100644
index 0000000..b139195
--- /dev/null
+++ b/templates/emails/plain/failed-renewal-authentication-requested.php
@@ -0,0 +1,49 @@
+<?php
+/**
+ * Admin email about payment retry failed due to authentication
+ *
+ * @package WooCommerce_Stripe/Templates/Emails
+ * @version 4.3.0
+ */
+
+if ( ! defined( 'ABSPATH' ) ) {
+	exit;
+}
+
+echo '= ' . $email_heading . " =\n\n";
+
+printf(
+	// translators: 1) an order number, 2) the customer's full name, 3) lowercase human time diff in the form returned by wcs_get_human_time_diff(), e.g. 'in 12 hours'.
+	_x(
+		'The automatic recurring payment for order %1$s from %2$s has failed. The customer was sent an email requesting authentication of payment. If the customer does not authenticate the payment, they will be requested by email again %3$s.',
+		'In admin renewal failed email',
+		'woocommerce-gateway-stripe'
+	),
+	$order->get_order_number(),
+	$order->get_formatted_billing_full_name(),
+	wcs_get_human_time_diff( $retry->get_time() )
+) . "\n\n";
+printf( __( 'The renewal order is as follows:', 'woocommerce-gateway-stripe' ) ) . "\n\n";
+
+echo "=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n";
+
+/**
+ * Shows the order details table.
+ */
+do_action( 'woocommerce_email_order_details', $order, $sent_to_admin, $plain_text, $email );
+
+echo "\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n";
+
+/**
+* Shows order meta data.
+*/
+do_action( 'woocommerce_email_order_meta', $order, $sent_to_admin, $plain_text, $email );
+
+/**
+* Shows customer details, and email address.
+*/
+do_action( 'woocommerce_email_customer_details', $order, $sent_to_admin, $plain_text, $email );
+
+echo "\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n";
+
+echo apply_filters( 'woocommerce_email_footer_text', get_option( 'woocommerce_email_footer_text' ) );
diff --git a/templates/emails/plain/failed-renewal-authentication.php b/templates/emails/plain/failed-renewal-authentication.php
new file mode 100644
index 0000000..84bd816
--- /dev/null
+++ b/templates/emails/plain/failed-renewal-authentication.php
@@ -0,0 +1,17 @@
+<?php
+if ( ! defined( 'ABSPATH' ) ) {
+	exit; // Exit if accessed directly
+}
+
+echo $email_heading . "\n\n";
+
+// translators: 1) name of the blog, 2) link to checkout payment url, note: no full stop due to url at the end
+printf( esc_html_x( 'The automatic payment to renew your subscription with %1$s has failed. To reactivate the subscription, please login and authorize the renewal from your account page: %2$s', 'In failed renewal authentication email', 'woocommerce-gateway-stripe' ), esc_html( get_bloginfo( 'name' ) ), esc_attr( $authorization_url ) );
+
+echo "\n\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n";
+
+do_action( 'woocommerce_subscriptions_email_order_details', $order, $sent_to_admin, $plain_text, $email );
+
+echo "\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n\n";
+
+echo apply_filters( 'woocommerce_email_footer_text', get_option( 'woocommerce_email_footer_text' ) );
diff --git a/templates/emails/plain/index.html b/templates/emails/plain/index.html
new file mode 100644
index 0000000..c8b94eb
--- /dev/null
+++ b/templates/emails/plain/index.html
@@ -0,0 +1,11 @@
+<html><head><title> - Revision 2844313: /woocommerce-gateway-stripe/trunk/templates/emails/plain</title></head>
+<body>
+ <h2> - Revision 2844313: /woocommerce-gateway-stripe/trunk/templates/emails/plain</h2>
+ <ul>
+  <li><a href="../">..</a></li>
+  <li><a href="failed-preorder-authentication.php">failed-preorder-authentication.php</a></li>
+  <li><a href="failed-renewal-authentication-requested.php">failed-renewal-authentication-requested.php</a></li>
+  <li><a href="failed-renewal-authentication.php">failed-renewal-authentication.php</a></li>
+ </ul>
+ <hr noshade><em>Powered by <a href="http://subversion.apache.org/">Apache Subversion</a> version 1.9.5 (r1770682).</em>
+</body></html>
\ No newline at end of file
