@better-auth/stripe 1.3.24 → 1.3.26

package/.turbo/turbo-build.log

@@ -1,17 +1,17 @@
 
-> @better-auth/stripe@1.3.24 build /home/runner/work/better-auth/better-auth/packages/stripe
+> @better-auth/stripe@1.3.26 build /home/runner/work/better-auth/better-auth/packages/stripe
 > unbuild
 
 [info] Automatically detected entries: src/index, src/client [esm] [cjs] [dts]
 [info] Building stripe
 [success] Build succeeded for stripe
-[log]   dist/index.cjs (total size: 45.3 kB, chunk size: 45.3 kB, exports: stripe)
+[log]   dist/index.cjs (total size: 49 kB, chunk size: 49 kB, exports: stripe)
 
 [log]   dist/client.cjs (total size: 270 B, chunk size: 270 B, exports: stripeClient)
 
-[log]   dist/index.mjs (total size: 44.5 kB, chunk size: 44.5 kB, exports: stripe)
+[log]   dist/index.mjs (total size: 48.2 kB, chunk size: 48.2 kB, exports: stripe)
 
 [log]   dist/client.mjs (total size: 243 B, chunk size: 243 B, exports: stripeClient)
 
-Σ Total dist size (byte size): 227 kB
+Σ Total dist size (byte size): 236 kB
 [log]

package/dist/index.cjs

@@ -5,6 +5,7 @@ const plugins = require('better-auth/plugins');
 const z = require('zod/v4');
 const api = require('better-auth/api');
 const db = require('better-auth/db');
+const defu = require('defu');
 
 function _interopNamespaceCompat(e) {
 	if (e && typeof e === 'object' && 'default' in e) return e;
@@ -550,16 +551,6 @@ const stripe = (options) => {
             });
           }
         }
-        const activeSubscriptions = await client.subscriptions.list({
-          customer: customerId
-        }).then(
-          (res) => res.data.filter(
-            (sub) => sub.status === "active" || sub.status === "trialing"
-          )
-        );
-        const activeSubscription = activeSubscriptions.find(
-          (sub) => subscriptionToUpdate?.stripeSubscriptionId || ctx.body.subscriptionId ? sub.id === subscriptionToUpdate?.stripeSubscriptionId || sub.id === ctx.body.subscriptionId : false
-        );
         const subscriptions = subscriptionToUpdate ? [subscriptionToUpdate] : await ctx.context.adapter.findMany({
           model: "subscription",
           where: [
@@ -572,6 +563,22 @@ const stripe = (options) => {
         const activeOrTrialingSubscription = subscriptions.find(
           (sub) => sub.status === "active" || sub.status === "trialing"
         );
+        const activeSubscriptions = await client.subscriptions.list({
+          customer: customerId
+        }).then(
+          (res) => res.data.filter(
+            (sub) => sub.status === "active" || sub.status === "trialing"
+          )
+        );
+        const activeSubscription = activeSubscriptions.find((sub) => {
+          if (subscriptionToUpdate?.stripeSubscriptionId || ctx.body.subscriptionId) {
+            return sub.id === subscriptionToUpdate?.stripeSubscriptionId || sub.id === ctx.body.subscriptionId;
+          }
+          if (activeOrTrialingSubscription?.stripeSubscriptionId) {
+            return sub.id === activeOrTrialingSubscription.stripeSubscriptionId;
+          }
+          return false;
+        });
         const incompleteSubscription = subscriptions.find(
           (sub) => sub.status === "incomplete"
         );
@@ -581,6 +588,54 @@ const stripe = (options) => {
           });
         }
         if (activeSubscription && customerId) {
+          let dbSubscription = await ctx.context.adapter.findOne({
+            model: "subscription",
+            where: [
+              {
+                field: "stripeSubscriptionId",
+                value: activeSubscription.id
+              }
+            ]
+          });
+          if (!dbSubscription && activeOrTrialingSubscription) {
+            await ctx.context.adapter.update({
+              model: "subscription",
+              update: {
+                stripeSubscriptionId: activeSubscription.id,
+                updatedAt: /* @__PURE__ */ new Date()
+              },
+              where: [
+                {
+                  field: "id",
+                  value: activeOrTrialingSubscription.id
+                }
+              ]
+            });
+            dbSubscription = activeOrTrialingSubscription;
+          }
+          let priceIdToUse2 = void 0;
+          if (ctx.body.annual) {
+            priceIdToUse2 = plan.annualDiscountPriceId;
+            if (!priceIdToUse2 && plan.annualDiscountLookupKey) {
+              priceIdToUse2 = await resolvePriceIdFromLookupKey(
+                client,
+                plan.annualDiscountLookupKey
+              );
+            }
+          } else {
+            priceIdToUse2 = plan.priceId;
+            if (!priceIdToUse2 && plan.lookupKey) {
+              priceIdToUse2 = await resolvePriceIdFromLookupKey(
+                client,
+                plan.lookupKey
+              );
+            }
+          }
+          if (!priceIdToUse2) {
+            throw ctx.error("BAD_REQUEST", {
+              message: "Price ID not found for the selected plan"
+            });
+          }
           const { url } = await client.billingPortal.sessions.create({
             customer: customerId,
             return_url: getUrl(ctx, ctx.body.returnUrl || "/"),
@@ -598,7 +653,7 @@ const stripe = (options) => {
                   {
                     id: activeSubscription.items.data[0]?.id,
                     quantity: ctx.body.seats || 1,
-                    price: ctx.body.annual ? plan.annualDiscountPriceId : plan.priceId
+                    price: priceIdToUse2
                   }
                 ]
               }
@@ -1314,13 +1369,24 @@ const stripe = (options) => {
               create: {
                 async after(user, ctx2) {
                   if (ctx2 && options.createCustomerOnSignUp) {
-                    const stripeCustomer = await client.customers.create({
-                      email: user.email,
-                      name: user.name,
-                      metadata: {
-                        userId: user.id
-                      }
-                    });
+                    let extraCreateParams = {};
+                    if (options.getCustomerCreateParams) {
+                      extraCreateParams = await options.getCustomerCreateParams(
+                        user,
+                        ctx2
+                      );
+                    }
+                    const params = defu.defu(
+                      {
+                        email: user.email,
+                        name: user.name,
+                        metadata: {
+                          userId: user.id
+                        }
+                      },
+                      extraCreateParams
+                    );
+                    const stripeCustomer = await client.customers.create(params);
                     await ctx2.context.internalAdapter.updateUser(user.id, {
                       stripeCustomerId: stripeCustomer.id
                     });
@@ -1336,6 +1402,40 @@ const stripe = (options) => {
                     );
                   }
                 }
+              },
+              update: {
+                async after(user, ctx2) {
+                  if (!ctx2) return;
+                  try {
+                    const userWithStripe = user;
+                    if (!userWithStripe.stripeCustomerId) return;
+                    const stripeCustomer = await client.customers.retrieve(
+                      userWithStripe.stripeCustomerId
+                    );
+                    if (stripeCustomer.deleted) {
+                      ctx2.context.logger.warn(
+                        `Stripe customer ${userWithStripe.stripeCustomerId} was deleted, cannot update email`
+                      );
+                      return;
+                    }
+                    if (stripeCustomer.email !== user.email) {
+                      await client.customers.update(
+                        userWithStripe.stripeCustomerId,
+                        {
+                          email: user.email
+                        }
+                      );
+                      ctx2.context.logger.info(
+                        `Updated Stripe customer email from ${stripeCustomer.email} to ${user.email}`
+                      );
+                    }
+                  } catch (e) {
+                    ctx2.context.logger.error(
+                      `Failed to sync email to Stripe customer: ${e.message}`,
+                      e
+                    );
+                  }
+                }
               }
             }
           }

package/dist/index.d.cts

@@ -240,10 +240,7 @@ interface StripeOptions {
      * @param data - data containing user and session
      * @returns
      */
-    getCustomerCreateParams?: (data: {
-        user: User;
-        session: Session;
-    }, ctx: GenericEndpointContext) => Promise<{}>;
+    getCustomerCreateParams?: (user: User, ctx: GenericEndpointContext) => Promise<Partial<Stripe.CustomerCreateParams>>;
     /**
      * Subscriptions
      */
@@ -1081,6 +1078,17 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                             image?: string | null | undefined;
                         } & Record<string, unknown>, ctx: GenericEndpointContext | undefined): Promise<void>;
                     };
+                    update: {
+                        after(user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        } & Record<string, unknown>, ctx: GenericEndpointContext | undefined): Promise<void>;
+                    };
                 };
             };
         };

package/dist/index.d.mts

@@ -240,10 +240,7 @@ interface StripeOptions {
      * @param data - data containing user and session
      * @returns
      */
-    getCustomerCreateParams?: (data: {
-        user: User;
-        session: Session;
-    }, ctx: GenericEndpointContext) => Promise<{}>;
+    getCustomerCreateParams?: (user: User, ctx: GenericEndpointContext) => Promise<Partial<Stripe.CustomerCreateParams>>;
     /**
      * Subscriptions
      */
@@ -1081,6 +1078,17 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                             image?: string | null | undefined;
                         } & Record<string, unknown>, ctx: GenericEndpointContext | undefined): Promise<void>;
                     };
+                    update: {
+                        after(user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        } & Record<string, unknown>, ctx: GenericEndpointContext | undefined): Promise<void>;
+                    };
                 };
             };
         };

package/dist/index.d.ts

@@ -240,10 +240,7 @@ interface StripeOptions {
      * @param data - data containing user and session
      * @returns
      */
-    getCustomerCreateParams?: (data: {
-        user: User;
-        session: Session;
-    }, ctx: GenericEndpointContext) => Promise<{}>;
+    getCustomerCreateParams?: (user: User, ctx: GenericEndpointContext) => Promise<Partial<Stripe.CustomerCreateParams>>;
     /**
      * Subscriptions
      */
@@ -1081,6 +1078,17 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                             image?: string | null | undefined;
                         } & Record<string, unknown>, ctx: GenericEndpointContext | undefined): Promise<void>;
                     };
+                    update: {
+                        after(user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        } & Record<string, unknown>, ctx: GenericEndpointContext | undefined): Promise<void>;
+                    };
                 };
             };
         };

package/dist/index.mjs

@@ -3,6 +3,7 @@ import { createAuthEndpoint, createAuthMiddleware } from 'better-auth/plugins';
 import * as z from 'zod/v4';
 import { sessionMiddleware, originCheck, APIError, getSessionFromCtx } from 'better-auth/api';
 import { mergeSchema } from 'better-auth/db';
+import { defu } from 'defu';
 
 async function getPlans(options) {
   return typeof options?.subscription?.plans === "function" ? await options.subscription?.plans() : options.subscription?.plans;
@@ -534,16 +535,6 @@ const stripe = (options) => {
             });
           }
         }
-        const activeSubscriptions = await client.subscriptions.list({
-          customer: customerId
-        }).then(
-          (res) => res.data.filter(
-            (sub) => sub.status === "active" || sub.status === "trialing"
-          )
-        );
-        const activeSubscription = activeSubscriptions.find(
-          (sub) => subscriptionToUpdate?.stripeSubscriptionId || ctx.body.subscriptionId ? sub.id === subscriptionToUpdate?.stripeSubscriptionId || sub.id === ctx.body.subscriptionId : false
-        );
         const subscriptions = subscriptionToUpdate ? [subscriptionToUpdate] : await ctx.context.adapter.findMany({
           model: "subscription",
           where: [
@@ -556,6 +547,22 @@ const stripe = (options) => {
         const activeOrTrialingSubscription = subscriptions.find(
           (sub) => sub.status === "active" || sub.status === "trialing"
         );
+        const activeSubscriptions = await client.subscriptions.list({
+          customer: customerId
+        }).then(
+          (res) => res.data.filter(
+            (sub) => sub.status === "active" || sub.status === "trialing"
+          )
+        );
+        const activeSubscription = activeSubscriptions.find((sub) => {
+          if (subscriptionToUpdate?.stripeSubscriptionId || ctx.body.subscriptionId) {
+            return sub.id === subscriptionToUpdate?.stripeSubscriptionId || sub.id === ctx.body.subscriptionId;
+          }
+          if (activeOrTrialingSubscription?.stripeSubscriptionId) {
+            return sub.id === activeOrTrialingSubscription.stripeSubscriptionId;
+          }
+          return false;
+        });
         const incompleteSubscription = subscriptions.find(
           (sub) => sub.status === "incomplete"
         );
@@ -565,6 +572,54 @@ const stripe = (options) => {
           });
         }
         if (activeSubscription && customerId) {
+          let dbSubscription = await ctx.context.adapter.findOne({
+            model: "subscription",
+            where: [
+              {
+                field: "stripeSubscriptionId",
+                value: activeSubscription.id
+              }
+            ]
+          });
+          if (!dbSubscription && activeOrTrialingSubscription) {
+            await ctx.context.adapter.update({
+              model: "subscription",
+              update: {
+                stripeSubscriptionId: activeSubscription.id,
+                updatedAt: /* @__PURE__ */ new Date()
+              },
+              where: [
+                {
+                  field: "id",
+                  value: activeOrTrialingSubscription.id
+                }
+              ]
+            });
+            dbSubscription = activeOrTrialingSubscription;
+          }
+          let priceIdToUse2 = void 0;
+          if (ctx.body.annual) {
+            priceIdToUse2 = plan.annualDiscountPriceId;
+            if (!priceIdToUse2 && plan.annualDiscountLookupKey) {
+              priceIdToUse2 = await resolvePriceIdFromLookupKey(
+                client,
+                plan.annualDiscountLookupKey
+              );
+            }
+          } else {
+            priceIdToUse2 = plan.priceId;
+            if (!priceIdToUse2 && plan.lookupKey) {
+              priceIdToUse2 = await resolvePriceIdFromLookupKey(
+                client,
+                plan.lookupKey
+              );
+            }
+          }
+          if (!priceIdToUse2) {
+            throw ctx.error("BAD_REQUEST", {
+              message: "Price ID not found for the selected plan"
+            });
+          }
           const { url } = await client.billingPortal.sessions.create({
             customer: customerId,
             return_url: getUrl(ctx, ctx.body.returnUrl || "/"),
@@ -582,7 +637,7 @@ const stripe = (options) => {
                   {
                     id: activeSubscription.items.data[0]?.id,
                     quantity: ctx.body.seats || 1,
-                    price: ctx.body.annual ? plan.annualDiscountPriceId : plan.priceId
+                    price: priceIdToUse2
                   }
                 ]
               }
@@ -1298,13 +1353,24 @@ const stripe = (options) => {
               create: {
                 async after(user, ctx2) {
                   if (ctx2 && options.createCustomerOnSignUp) {
-                    const stripeCustomer = await client.customers.create({
-                      email: user.email,
-                      name: user.name,
-                      metadata: {
-                        userId: user.id
-                      }
-                    });
+                    let extraCreateParams = {};
+                    if (options.getCustomerCreateParams) {
+                      extraCreateParams = await options.getCustomerCreateParams(
+                        user,
+                        ctx2
+                      );
+                    }
+                    const params = defu(
+                      {
+                        email: user.email,
+                        name: user.name,
+                        metadata: {
+                          userId: user.id
+                        }
+                      },
+                      extraCreateParams
+                    );
+                    const stripeCustomer = await client.customers.create(params);
                     await ctx2.context.internalAdapter.updateUser(user.id, {
                       stripeCustomerId: stripeCustomer.id
                     });
@@ -1320,6 +1386,40 @@ const stripe = (options) => {
                     );
                   }
                 }
+              },
+              update: {
+                async after(user, ctx2) {
+                  if (!ctx2) return;
+                  try {
+                    const userWithStripe = user;
+                    if (!userWithStripe.stripeCustomerId) return;
+                    const stripeCustomer = await client.customers.retrieve(
+                      userWithStripe.stripeCustomerId
+                    );
+                    if (stripeCustomer.deleted) {
+                      ctx2.context.logger.warn(
+                        `Stripe customer ${userWithStripe.stripeCustomerId} was deleted, cannot update email`
+                      );
+                      return;
+                    }
+                    if (stripeCustomer.email !== user.email) {
+                      await client.customers.update(
+                        userWithStripe.stripeCustomerId,
+                        {
+                          email: user.email
+                        }
+                      );
+                      ctx2.context.logger.info(
+                        `Updated Stripe customer email from ${stripeCustomer.email} to ${user.email}`
+                      );
+                    }
+                  } catch (e) {
+                    ctx2.context.logger.error(
+                      `Failed to sync email to Stripe customer: ${e.message}`,
+                      e
+                    );
+                  }
+                }
               }
             }
           }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@better-auth/stripe",
   "author": "Bereket Engida",
-  "version": "1.3.24",
+  "version": "1.3.26",
   "main": "dist/index.cjs",
   "license": "MIT",
   "keywords": [
@@ -37,17 +37,18 @@
     }
   },
   "dependencies": {
+    "defu": "^6.1.4",
     "zod": "^4.1.5"
   },
   "peerDependencies": {
     "stripe": "^18",
-    "better-auth": "1.3.24"
+    "better-auth": "1.3.26"
   },
   "devDependencies": {
     "better-call": "1.0.19",
     "stripe": "^18.5.0",
     "unbuild": "3.6.1",
-    "better-auth": "1.3.24"
+    "better-auth": "1.3.26"
   },
   "scripts": {
     "test": "vitest",

package/src/index.ts

@@ -26,6 +26,7 @@ import type {
 } from "./types";
 import { getPlanByName, getPlanByPriceInfo, getPlans } from "./utils";
 import { getSchema } from "./schema";
+import { defu } from "defu";
 
 const STRIPE_ERROR_CODES = {
 	SUBSCRIPTION_NOT_FOUND: "Subscription not found",
@@ -325,23 +326,6 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 					}
 				}
 
-				const activeSubscriptions = await client.subscriptions
-					.list({
-						customer: customerId,
-					})
-					.then((res) =>
-						res.data.filter(
-							(sub) => sub.status === "active" || sub.status === "trialing",
-						),
-					);
-
-				const activeSubscription = activeSubscriptions.find((sub) =>
-					subscriptionToUpdate?.stripeSubscriptionId || ctx.body.subscriptionId
-						? sub.id === subscriptionToUpdate?.stripeSubscriptionId ||
-							sub.id === ctx.body.subscriptionId
-						: false,
-				);
-
 				const subscriptions = subscriptionToUpdate
 					? [subscriptionToUpdate]
 					: await ctx.context.adapter.findMany<Subscription>({
@@ -358,6 +342,34 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 					(sub) => sub.status === "active" || sub.status === "trialing",
 				);
 
+				const activeSubscriptions = await client.subscriptions
+					.list({
+						customer: customerId,
+					})
+					.then((res) =>
+						res.data.filter(
+							(sub) => sub.status === "active" || sub.status === "trialing",
+						),
+					);
+
+				const activeSubscription = activeSubscriptions.find((sub) => {
+					// If we have a specific subscription to update, match by ID
+					if (
+						subscriptionToUpdate?.stripeSubscriptionId ||
+						ctx.body.subscriptionId
+					) {
+						return (
+							sub.id === subscriptionToUpdate?.stripeSubscriptionId ||
+							sub.id === ctx.body.subscriptionId
+						);
+					}
+					// Only find subscription for the same referenceId to avoid mixing personal and org subscriptions
+					if (activeOrTrialingSubscription?.stripeSubscriptionId) {
+						return sub.id === activeOrTrialingSubscription.stripeSubscriptionId;
+					}
+					return false;
+				});
+
 				// Also find any incomplete subscription that we can reuse
 				const incompleteSubscription = subscriptions.find(
 					(sub) => sub.status === "incomplete",
@@ -375,6 +387,61 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 				}
 
 				if (activeSubscription && customerId) {
+					// Find the corresponding database subscription for this Stripe subscription
+					let dbSubscription = await ctx.context.adapter.findOne<Subscription>({
+						model: "subscription",
+						where: [
+							{
+								field: "stripeSubscriptionId",
+								value: activeSubscription.id,
+							},
+						],
+					});
+
+					// If no database record exists for this Stripe subscription, update the existing one
+					if (!dbSubscription && activeOrTrialingSubscription) {
+						await ctx.context.adapter.update<InputSubscription>({
+							model: "subscription",
+							update: {
+								stripeSubscriptionId: activeSubscription.id,
+								updatedAt: new Date(),
+							},
+							where: [
+								{
+									field: "id",
+									value: activeOrTrialingSubscription.id,
+								},
+							],
+						});
+						dbSubscription = activeOrTrialingSubscription;
+					}
+
+					// Resolve price ID if using lookup keys
+					let priceIdToUse: string | undefined = undefined;
+					if (ctx.body.annual) {
+						priceIdToUse = plan.annualDiscountPriceId;
+						if (!priceIdToUse && plan.annualDiscountLookupKey) {
+							priceIdToUse = await resolvePriceIdFromLookupKey(
+								client,
+								plan.annualDiscountLookupKey,
+							);
+						}
+					} else {
+						priceIdToUse = plan.priceId;
+						if (!priceIdToUse && plan.lookupKey) {
+							priceIdToUse = await resolvePriceIdFromLookupKey(
+								client,
+								plan.lookupKey,
+							);
+						}
+					}
+
+					if (!priceIdToUse) {
+						throw ctx.error("BAD_REQUEST", {
+							message: "Price ID not found for the selected plan",
+						});
+					}
+
 					const { url } = await client.billingPortal.sessions
 						.create({
 							customer: customerId,
@@ -393,9 +460,7 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 										{
 											id: activeSubscription.items.data[0]?.id as string,
 											quantity: ctx.body.seats || 1,
-											price: ctx.body.annual
-												? plan.annualDiscountPriceId
-												: plan.priceId,
+											price: priceIdToUse,
 										},
 									],
 								},
@@ -1235,13 +1300,27 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 							create: {
 								async after(user, ctx) {
 									if (ctx && options.createCustomerOnSignUp) {
-										const stripeCustomer = await client.customers.create({
-											email: user.email,
-											name: user.name,
-											metadata: {
-												userId: user.id,
+										let extraCreateParams: Partial<Stripe.CustomerCreateParams> =
+											{};
+										if (options.getCustomerCreateParams) {
+											extraCreateParams = await options.getCustomerCreateParams(
+												user,
+												ctx,
+											);
+										}
+
+										const params: Stripe.CustomerCreateParams = defu(
+											{
+												email: user.email,
+												name: user.name,
+												metadata: {
+													userId: user.id,
+												},
 											},
-										});
+											extraCreateParams,
+										);
+										const stripeCustomer =
+											await client.customers.create(params);
 										await ctx.context.internalAdapter.updateUser(user.id, {
 											stripeCustomerId: stripeCustomer.id,
 										});
@@ -1258,6 +1337,56 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 									}
 								},
 							},
+							update: {
+								async after(user, ctx) {
+									if (!ctx) return;
+
+									try {
+										// Cast user to include stripeCustomerId (added by the stripe plugin schema)
+										const userWithStripe = user as typeof user & {
+											stripeCustomerId?: string;
+										};
+
+										// Only proceed if user has a Stripe customer ID
+										if (!userWithStripe.stripeCustomerId) return;
+
+										// Get the user from the database to check if email actually changed
+										// The 'user' parameter here is the freshly updated user
+										// We need to check if the Stripe customer's email matches
+										const stripeCustomer = await client.customers.retrieve(
+											userWithStripe.stripeCustomerId,
+										);
+
+										// Check if customer was deleted
+										if (stripeCustomer.deleted) {
+											ctx.context.logger.warn(
+												`Stripe customer ${userWithStripe.stripeCustomerId} was deleted, cannot update email`,
+											);
+											return;
+										}
+
+										// If Stripe customer email doesn't match the user's current email, update it
+										if (stripeCustomer.email !== user.email) {
+											await client.customers.update(
+												userWithStripe.stripeCustomerId,
+												{
+													email: user.email,
+												},
+											);
+											ctx.context.logger.info(
+												`Updated Stripe customer email from ${stripeCustomer.email} to ${user.email}`,
+											);
+										}
+									} catch (e: any) {
+										// Ignore errors - this is a best-effort sync
+										// Email might have been deleted or Stripe customer might not exist
+										ctx.context.logger.error(
+											`Failed to sync email to Stripe customer: ${e.message}`,
+											e,
+										);
+									}
+								},
+							},
 						},
 					},
 				},

package/src/stripe.test.ts

@@ -17,6 +17,16 @@ describe("stripe", async () => {
 		},
 		customers: {
 			create: vi.fn().mockResolvedValue({ id: "cus_mock123" }),
+			list: vi.fn().mockResolvedValue({ data: [] }),
+			retrieve: vi.fn().mockResolvedValue({
+				id: "cus_mock123",
+				email: "test@email.com",
+				deleted: false,
+			}),
+			update: vi.fn().mockResolvedValue({
+				id: "cus_mock123",
+				email: "newemail@example.com",
+			}),
 		},
 		checkout: {
 			sessions: {
@@ -1188,6 +1198,141 @@ describe("stripe", async () => {
 		expect(hasTrialData).toBe(true);
 	});
 
+	it("should upgrade existing subscription instead of creating new one", async () => {
+		// Reset mocks for this test
+		vi.clearAllMocks();
+
+		// Create a user
+		const userRes = await authClient.signUp.email(
+			{ ...testUser, email: "upgrade-existing@email.com" },
+			{ throw: true },
+		);
+
+		const headers = new Headers();
+		await authClient.signIn.email(
+			{ ...testUser, email: "upgrade-existing@email.com" },
+			{
+				throw: true,
+				onSuccess: setCookieToHeader(headers),
+			},
+		);
+
+		// Mock customers.list to find existing customer
+		mockStripe.customers.list.mockResolvedValueOnce({
+			data: [{ id: "cus_test_123" }],
+		});
+
+		// First create a starter subscription
+		await authClient.subscription.upgrade({
+			plan: "starter",
+			fetchOptions: { headers },
+		});
+
+		// Simulate the subscription being active
+		const starterSub = await ctx.adapter.findOne<Subscription>({
+			model: "subscription",
+			where: [
+				{
+					field: "referenceId",
+					value: userRes.user.id,
+				},
+			],
+		});
+
+		await ctx.adapter.update({
+			model: "subscription",
+			update: {
+				status: "active",
+				stripeSubscriptionId: "sub_active_test_123",
+				stripeCustomerId: "cus_mock123", // Use the same customer ID as the mock
+			},
+			where: [
+				{
+					field: "id",
+					value: starterSub!.id,
+				},
+			],
+		});
+
+		// Also update the user with the Stripe customer ID
+		await ctx.adapter.update({
+			model: "user",
+			update: {
+				stripeCustomerId: "cus_mock123",
+			},
+			where: [
+				{
+					field: "id",
+					value: userRes.user.id,
+				},
+			],
+		});
+
+		// Mock Stripe subscriptions.list to return the active subscription
+		mockStripe.subscriptions.list.mockResolvedValueOnce({
+			data: [
+				{
+					id: "sub_active_test_123",
+					status: "active",
+					items: {
+						data: [
+							{
+								id: "si_test_123",
+								price: { id: process.env.STRIPE_PRICE_ID_1 },
+								quantity: 1,
+								current_period_start: Math.floor(Date.now() / 1000),
+								current_period_end:
+									Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+							},
+						],
+					},
+				},
+			],
+		});
+
+		// Clear mock calls before the upgrade
+		mockStripe.checkout.sessions.create.mockClear();
+		mockStripe.billingPortal.sessions.create.mockClear();
+
+		// Now upgrade to premium plan - should use billing portal to update existing subscription
+		const upgradeRes = await authClient.subscription.upgrade({
+			plan: "premium",
+			fetchOptions: { headers },
+		});
+
+		// Verify that billing portal was called (indicating update, not new subscription)
+		expect(mockStripe.billingPortal.sessions.create).toHaveBeenCalledWith(
+			expect.objectContaining({
+				customer: "cus_mock123",
+				flow_data: expect.objectContaining({
+					type: "subscription_update_confirm",
+					subscription_update_confirm: expect.objectContaining({
+						subscription: "sub_active_test_123",
+					}),
+				}),
+			}),
+		);
+
+		// Should not create a new checkout session
+		expect(mockStripe.checkout.sessions.create).not.toHaveBeenCalled();
+
+		// Verify the response has a redirect URL
+		expect(upgradeRes.data?.url).toBe("https://billing.stripe.com/mock");
+		expect(upgradeRes.data?.redirect).toBe(true);
+
+		// Verify no new subscription was created in the database
+		const allSubs = await ctx.adapter.findMany<Subscription>({
+			model: "subscription",
+			where: [
+				{
+					field: "referenceId",
+					value: userRes.user.id,
+				},
+			],
+		});
+		expect(allSubs).toHaveLength(1); // Should still have only one subscription
+	});
+
 	it("should prevent multiple free trials across different plans", async () => {
 		// Create a user
 		const userRes = await authClient.signUp.email(
@@ -1280,4 +1425,318 @@ describe("stripe", async () => {
 		});
 		expect(hasEverTrialed).toBe(true);
 	});
+
+	it("should update stripe customer email when user email changes", async () => {
+		// Setup mock for customer retrieve and update
+		mockStripe.customers.retrieve = vi.fn().mockResolvedValue({
+			id: "cus_mock123",
+			email: "test@email.com",
+			deleted: false,
+		});
+		mockStripe.customers.update = vi.fn().mockResolvedValue({
+			id: "cus_mock123",
+			email: "newemail@example.com",
+		});
+
+		// Sign up a user
+		const userRes = await authClient.signUp.email(testUser, {
+			throw: true,
+		});
+
+		expect(userRes.user).toBeDefined();
+
+		// Verify customer was created during signup
+		expect(mockStripe.customers.create).toHaveBeenCalledWith({
+			email: testUser.email,
+			name: testUser.name,
+			metadata: {
+				userId: userRes.user.id,
+			},
+		});
+
+		// Clear mocks to track the update
+		vi.clearAllMocks();
+
+		// Re-setup the retrieve mock for the update flow
+		mockStripe.customers.retrieve = vi.fn().mockResolvedValue({
+			id: "cus_mock123",
+			email: "test@email.com",
+			deleted: false,
+		});
+		mockStripe.customers.update = vi.fn().mockResolvedValue({
+			id: "cus_mock123",
+			email: "newemail@example.com",
+		});
+
+		// Create a mock request context
+		const mockRequest = new Request("http://localhost:3000/api/test", {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+			},
+		});
+
+		// Update the user's email using internal adapter (which triggers hooks)
+		await ctx.internalAdapter.updateUserByEmail(
+			testUser.email,
+			{
+				email: "newemail@example.com",
+			},
+			{
+				request: mockRequest,
+				context: ctx,
+			} as any,
+		);
+
+		// Verify that Stripe customer.retrieve was called
+		expect(mockStripe.customers.retrieve).toHaveBeenCalledWith("cus_mock123");
+
+		// Verify that Stripe customer.update was called with the new email
+		expect(mockStripe.customers.update).toHaveBeenCalledWith("cus_mock123", {
+			email: "newemail@example.com",
+		});
+	});
+
+	describe("getCustomerCreateParams", () => {
+		it("should call getCustomerCreateParams and merge with default params", async () => {
+			const getCustomerCreateParamsMock = vi
+				.fn()
+				.mockResolvedValue({ metadata: { customField: "customValue" } });
+
+			const testOptions = {
+				...stripeOptions,
+				createCustomerOnSignUp: true,
+				getCustomerCreateParams: getCustomerCreateParamsMock,
+			} satisfies StripeOptions;
+
+			const testAuth = betterAuth({
+				database: memory,
+				baseURL: "http://localhost:3000",
+				emailAndPassword: {
+					enabled: true,
+				},
+				plugins: [stripe(testOptions)],
+			});
+
+			const testAuthClient = createAuthClient({
+				baseURL: "http://localhost:3000",
+				plugins: [bearer(), stripeClient({ subscription: true })],
+				fetchOptions: {
+					customFetchImpl: async (url, init) =>
+						testAuth.handler(new Request(url, init)),
+				},
+			});
+
+			// Sign up a user
+			const userRes = await testAuthClient.signUp.email(
+				{
+					email: "custom-params@email.com",
+					password: "password",
+					name: "Custom User",
+				},
+				{
+					throw: true,
+				},
+			);
+
+			// Verify getCustomerCreateParams was called
+			expect(getCustomerCreateParamsMock).toHaveBeenCalledWith(
+				expect.objectContaining({
+					id: userRes.user.id,
+					email: "custom-params@email.com",
+					name: "Custom User",
+				}),
+				expect.objectContaining({
+					context: expect.any(Object),
+				}),
+			);
+
+			// Verify customer was created with merged params
+			expect(mockStripe.customers.create).toHaveBeenCalledWith(
+				expect.objectContaining({
+					email: "custom-params@email.com",
+					name: "Custom User",
+					metadata: expect.objectContaining({
+						userId: userRes.user.id,
+						customField: "customValue",
+					}),
+				}),
+			);
+		});
+
+		it("should use getCustomerCreateParams to add custom address", async () => {
+			const getCustomerCreateParamsMock = vi.fn().mockResolvedValue({
+				address: {
+					line1: "123 Main St",
+					city: "San Francisco",
+					state: "CA",
+					postal_code: "94111",
+					country: "US",
+				},
+			});
+
+			const testOptions = {
+				...stripeOptions,
+				createCustomerOnSignUp: true,
+				getCustomerCreateParams: getCustomerCreateParamsMock,
+			} satisfies StripeOptions;
+
+			const testAuth = betterAuth({
+				database: memory,
+				baseURL: "http://localhost:3000",
+				emailAndPassword: {
+					enabled: true,
+				},
+				plugins: [stripe(testOptions)],
+			});
+
+			const testAuthClient = createAuthClient({
+				baseURL: "http://localhost:3000",
+				plugins: [bearer(), stripeClient({ subscription: true })],
+				fetchOptions: {
+					customFetchImpl: async (url, init) =>
+						testAuth.handler(new Request(url, init)),
+				},
+			});
+
+			// Sign up a user
+			await testAuthClient.signUp.email(
+				{
+					email: "address-user@email.com",
+					password: "password",
+					name: "Address User",
+				},
+				{
+					throw: true,
+				},
+			);
+
+			// Verify customer was created with address
+			expect(mockStripe.customers.create).toHaveBeenCalledWith(
+				expect.objectContaining({
+					email: "address-user@email.com",
+					name: "Address User",
+					address: {
+						line1: "123 Main St",
+						city: "San Francisco",
+						state: "CA",
+						postal_code: "94111",
+						country: "US",
+					},
+					metadata: expect.objectContaining({
+						userId: expect.any(String),
+					}),
+				}),
+			);
+		});
+
+		it("should properly merge nested objects using defu", async () => {
+			const getCustomerCreateParamsMock = vi.fn().mockResolvedValue({
+				metadata: {
+					customField: "customValue",
+					anotherField: "anotherValue",
+				},
+				phone: "+1234567890",
+			});
+
+			const testOptions = {
+				...stripeOptions,
+				createCustomerOnSignUp: true,
+				getCustomerCreateParams: getCustomerCreateParamsMock,
+			} satisfies StripeOptions;
+
+			const testAuth = betterAuth({
+				database: memory,
+				baseURL: "http://localhost:3000",
+				emailAndPassword: {
+					enabled: true,
+				},
+				plugins: [stripe(testOptions)],
+			});
+
+			const testAuthClient = createAuthClient({
+				baseURL: "http://localhost:3000",
+				plugins: [bearer(), stripeClient({ subscription: true })],
+				fetchOptions: {
+					customFetchImpl: async (url, init) =>
+						testAuth.handler(new Request(url, init)),
+				},
+			});
+
+			// Sign up a user
+			const userRes = await testAuthClient.signUp.email(
+				{
+					email: "merge-test@email.com",
+					password: "password",
+					name: "Merge User",
+				},
+				{
+					throw: true,
+				},
+			);
+
+			// Verify customer was created with properly merged params
+			// defu merges objects and preserves all fields
+			expect(mockStripe.customers.create).toHaveBeenCalledWith(
+				expect.objectContaining({
+					email: "merge-test@email.com",
+					name: "Merge User",
+					phone: "+1234567890",
+					metadata: {
+						userId: userRes.user.id,
+						customField: "customValue",
+						anotherField: "anotherValue",
+					},
+				}),
+			);
+		});
+
+		it("should work without getCustomerCreateParams", async () => {
+			// This test ensures backward compatibility
+			const testOptions = {
+				...stripeOptions,
+				createCustomerOnSignUp: true,
+				// No getCustomerCreateParams provided
+			} satisfies StripeOptions;
+
+			const testAuth = betterAuth({
+				database: memory,
+				baseURL: "http://localhost:3000",
+				emailAndPassword: {
+					enabled: true,
+				},
+				plugins: [stripe(testOptions)],
+			});
+
+			const testAuthClient = createAuthClient({
+				baseURL: "http://localhost:3000",
+				plugins: [bearer(), stripeClient({ subscription: true })],
+				fetchOptions: {
+					customFetchImpl: async (url, init) =>
+						testAuth.handler(new Request(url, init)),
+				},
+			});
+
+			// Sign up a user
+			const userRes = await testAuthClient.signUp.email(
+				{
+					email: "no-custom-params@email.com",
+					password: "password",
+					name: "Default User",
+				},
+				{
+					throw: true,
+				},
+			);
+
+			// Verify customer was created with default params only
+			expect(mockStripe.customers.create).toHaveBeenCalledWith({
+				email: "no-custom-params@email.com",
+				name: "Default User",
+				metadata: {
+					userId: userRes.user.id,
+				},
+			});
+		});
+	});
 });

package/src/types.ts

@@ -199,12 +199,9 @@ export interface StripeOptions {
 	 * @returns
 	 */
 	getCustomerCreateParams?: (
-		data: {
-			user: User;
-			session: Session;
-		},
+		user: User,
 		ctx: GenericEndpointContext,
-	) => Promise<{}>;
+	) => Promise<Partial<Stripe.CustomerCreateParams>>;
 	/**
 	 * Subscriptions
 	 */