diff --git a/frontend/src/components/modals/CancelOrderModal.tsx b/frontend/src/components/modals/CancelOrderModal.tsx
index 726d9fac..80e390eb 100644
--- a/frontend/src/components/modals/CancelOrderModal.tsx
+++ b/frontend/src/components/modals/CancelOrderModal.tsx
@@ -42,7 +42,7 @@ const CancelOrderModal: React.FC<CancelOrderModalProps> = ({
   const MAX_REASON_LENGTH = 500;
 
   const [cancellation, setCancellation] = useState({
-    payment_intent_id: order["stripe_payment_intent_id"],
+    payment_intent_id: order["stripe_payment_intent_id"] || "",
     cancel_reason: { reason: "", details: "" },
     amount: order["amount"],
   });
@@ -79,6 +79,12 @@ const CancelOrderModal: React.FC<CancelOrderModalProps> = ({
 
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
+
+    if (!cancellation.payment_intent_id) {
+      addErrorAlert("Invalid payment information");
+      return;
+    }
+
     try {
       const { data, error } = await client.PUT("/stripe/refunds/{order_id}", {
         params: { path: { order_id: order.id } },
diff --git a/frontend/src/components/pages/CreateSell.tsx b/frontend/src/components/pages/CreateSell.tsx
index 1cea195e..7c1097ce 100644
--- a/frontend/src/components/pages/CreateSell.tsx
+++ b/frontend/src/components/pages/CreateSell.tsx
@@ -27,111 +27,38 @@ const CreateSell = () => {
   const navigate = useNavigate();
 
   const [description, setDescription] = useState<string>("");
-  const [slug, setSlug] = useState<string>("");
-  const [previewUrl, setPreviewUrl] = useState<string>("");
   const [images, setImages] = useState<ImageListType>([]);
   const [displayPrice, setDisplayPrice] = useState<string>("0.00");
   const [isSubmitting, setIsSubmitting] = useState(false);
-  const [inventoryType, setInventoryType] = useState<
-    "infinite" | "finite" | "preorder"
-  >("infinite");
+  const [slug, setSlug] = useState<string>("");
+  const [previewUrl, setPreviewUrl] = useState<string>("");
+  const [price_amount, setPriceAmount] = useState<number>(0);
   const [isReservation, setIsReservation] = useState(false);
   const [displayDepositAmount, setDisplayDepositAmount] =
     useState<string>("0.00");
 
-  useEffect(() => {
-    if (!auth.currentUser?.stripe_connect_onboarding_completed) {
-      navigate(`${ROUTES.BOTS.path}/${ROUTES.BOTS.$.CREATE.relativePath}`);
-    }
-  }, [auth.currentUser, navigate]);
-
   const {
     register,
     handleSubmit,
     formState: { errors },
     watch,
     setValue,
-    trigger,
   } = useForm<SellListingType>({
     resolver: zodResolver(SellListingSchema),
-    mode: "onChange",
-    criteriaMode: "all",
-    shouldFocusError: true,
     defaultValues: {
       price_amount: 0,
       currency: "usd",
-      inventory_type: "infinite",
+      inventory_type: "finite",
       inventory_quantity: null,
       preorder_release_date: null,
       is_reservation: false,
       reservation_deposit_amount: null,
     },
-    shouldUseNativeValidation: false,
-    reValidateMode: "onChange",
-    context: {
-      validate: (data: SellListingType) => {
-        const {
-          price_amount,
-          currency,
-          inventory_type,
-          inventory_quantity,
-          preorder_release_date,
-          is_reservation,
-          reservation_deposit_amount,
-        } = data;
-        if ((price_amount && !currency) || (!price_amount && currency)) {
-          return {
-            price_amount:
-              "Price amount and currency must be provided together.",
-            currency: "Price amount and currency must be provided together.",
-          };
-        }
-        if (
-          (inventory_type && !inventory_quantity) ||
-          (!inventory_type && inventory_quantity)
-        ) {
-          return {
-            inventory_type:
-              "Inventory type and quantity must be provided together.",
-            inventory_quantity:
-              "Inventory type and quantity must be provided together.",
-          };
-        }
-        if (
-          (preorder_release_date && !is_reservation) ||
-          (!preorder_release_date && is_reservation)
-        ) {
-          return {
-            preorder_release_date:
-              "Preorder release date and reservation must be provided together.",
-            is_reservation:
-              "Preorder release date and reservation must be provided together.",
-          };
-        }
-        if (
-          (is_reservation && !reservation_deposit_amount) ||
-          (!is_reservation && reservation_deposit_amount)
-        ) {
-          return {
-            reservation_deposit_amount:
-              "Reservation deposit amount must be provided if reservation is true.",
-            is_reservation:
-              "Reservation deposit amount must be provided if reservation is true.",
-          };
-        }
-        return {};
-      },
-    },
   });
 
+  const inventoryType = watch("inventory_type");
   const name = watch("name");
 
-  const price_amount = watch("price_amount");
-  const currency = watch("currency");
-  const inventory_quantity = watch("inventory_quantity");
-  const preorder_release_date = watch("preorder_release_date");
-  const reservation_deposit_amount = watch("reservation_deposit_amount");
-
   useEffect(() => {
     if (name) {
       const newSlug = slugify(name);
@@ -142,119 +69,88 @@ const CreateSell = () => {
 
   useEffect(() => {
     if (auth.currentUser && slug) {
-      setPreviewUrl(`/bot/${auth.currentUser.username}/${slug}`);
+      setPreviewUrl(
+        `https://kscale.dev/bot/${auth.currentUser.username}/${slug}`,
+      );
     }
   }, [auth.currentUser, slug]);
 
-  useEffect(() => {
-    if ((price_amount && !currency) || (!price_amount && currency)) {
-      trigger(["price_amount", "currency"]);
-    }
-  }, [price_amount, currency, trigger]);
-
-  useEffect(() => {
-    if (
-      (inventory_quantity && !inventoryType) ||
-      (!inventory_quantity && inventoryType)
-    ) {
-      trigger(["inventory_quantity", "inventory_type"]);
-    }
-  }, [inventory_quantity, inventoryType, trigger]);
-
-  useEffect(() => {
-    if (
-      (preorder_release_date && !isReservation) ||
-      (!preorder_release_date && isReservation)
-    ) {
-      trigger(["preorder_release_date", "is_reservation"]);
-    }
-  }, [preorder_release_date, isReservation, trigger]);
-
-  useEffect(() => {
-    if (
-      (isReservation && !reservation_deposit_amount) ||
-      (!isReservation && reservation_deposit_amount)
-    ) {
-      trigger(["reservation_deposit_amount", "is_reservation"]);
-    }
-  }, [reservation_deposit_amount, isReservation, trigger]);
-
-  const handleImageChange = (imageList: ImageListType) => {
-    setImages(imageList);
-  };
-
   const handlePriceChange = (e: React.ChangeEvent<HTMLInputElement>) => {
     const inputValue = e.target.value.replace(/[^0-9]/g, "");
-
     if (!inputValue) {
+      setPriceAmount(0);
       setDisplayPrice("");
-      setValue("price_amount", null, { shouldValidate: true });
+      setValue("price_amount", null);
       return;
     }
-
     const decimalValue = convertToDecimal(inputValue);
+    setPriceAmount(parseFloat(decimalValue));
     setDisplayPrice(decimalValue);
-    setValue("price_amount", parseFloat(decimalValue), {
-      shouldValidate: true,
-    });
+    setValue("price_amount", parseFloat(decimalValue));
   };
 
   const handleDepositChange = (e: React.ChangeEvent<HTMLInputElement>) => {
     const inputValue = e.target.value.replace(/[^0-9]/g, "");
+    setDisplayDepositAmount(inputValue);
+    setValue("reservation_deposit_amount", parseFloat(inputValue));
+  };
 
-    if (!inputValue) {
-      setDisplayDepositAmount("");
-      setValue("reservation_deposit_amount", null, { shouldValidate: true });
-      return;
-    }
+  const handleImageChange = (imageList: ImageListType) => {
+    setImages(imageList);
+  };
 
-    const decimalValue = convertToDecimal(inputValue);
-    setDisplayDepositAmount(decimalValue);
-    setValue("reservation_deposit_amount", parseFloat(decimalValue), {
-      shouldValidate: true,
-    });
+  const handleDateChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const date = e.target.value;
+    if (date) {
+      // Convert the date to Unix timestamp in seconds
+      const timestamp = Math.floor(new Date(date).getTime() / 1000);
+      setValue("preorder_release_date", timestamp);
+    } else {
+      setValue("preorder_release_date", null);
+    }
   };
 
   const onSubmit = async (data: SellListingType) => {
-    console.log("Submitting data:", data);
     setIsSubmitting(true);
 
     const formData = new FormData();
     formData.append("name", data.name);
     formData.append("description", data.description || "");
-    formData.append("slug", data.slug || slugify(data.name));
-    formData.append(
-      "price_amount",
-      data.price_amount ? convertToCents(data.price_amount).toString() : "",
-    );
-    formData.append("currency", data.currency);
+    formData.append("slug", slugify(data.name));
+
+    if (data.price_amount) {
+      formData.append(
+        "price_amount",
+        convertToCents(data.price_amount).toString(),
+      );
+    }
+
+    formData.append("currency", "usd");
     formData.append("inventory_type", data.inventory_type);
-    formData.append(
-      "inventory_quantity",
-      data.inventory_quantity?.toString() || "",
-    );
-
-    // Convert preorder_release_date to a timestamp
-    const preorderReleaseDate = data.preorder_release_date
-      ? new Date(data.preorder_release_date).getTime() / 1000
-      : null;
-    formData.append(
-      "preorder_release_date",
-      preorderReleaseDate ? preorderReleaseDate.toString() : "",
-    );
-
-    formData.append("is_reservation", data.is_reservation?.toString() || "");
-    formData.append(
-      "reservation_deposit_amount",
-      data.reservation_deposit_amount
-        ? convertToCents(data.reservation_deposit_amount).toString()
-        : "",
-    );
-
-    // Append photos to formData
+
+    if (data.inventory_type === "finite" && data.inventory_quantity) {
+      formData.append("inventory_quantity", data.inventory_quantity.toString());
+    }
+
+    if (data.inventory_type === "preorder" && data.preorder_release_date) {
+      formData.append(
+        "preorder_release_date",
+        data.preorder_release_date.toString(),
+      );
+    }
+
+    formData.append("is_reservation", data.is_reservation.toString());
+    if (data.is_reservation && data.reservation_deposit_amount) {
+      formData.append(
+        "reservation_deposit_amount",
+        data.reservation_deposit_amount.toString(),
+      );
+    }
+
+    // Append photos
     images.forEach((image) => {
       if (image.file) {
-        formData.append(`photos`, image.file);
+        formData.append("photos", image.file);
       }
     });
 
@@ -268,7 +164,6 @@ const CreateSell = () => {
       );
 
       if (error) {
-        console.error("Server error:", error.detail);
         addErrorAlert(`Failed to create listing: ${error.detail}`);
         return;
       }
@@ -281,8 +176,6 @@ const CreateSell = () => {
             slug: responseData.slug,
           }),
         );
-      } else {
-        throw new Error("Invalid response data");
       }
     } catch (error) {
       console.error("Error creating listing:", error);
@@ -292,109 +185,47 @@ const CreateSell = () => {
     }
   };
 
-  const validateFields = () => {
-    if ((price_amount && !currency) || (!price_amount && currency)) {
-      return "Price amount and currency must be provided together or both left empty.";
-    }
-    if (
-      (inventory_quantity && !inventoryType) ||
-      (!inventory_quantity && inventoryType)
-    ) {
-      return "Inventory quantity and type must be provided together or both left empty.";
-    }
-    if (
-      (preorder_release_date && !isReservation) ||
-      (!preorder_release_date && isReservation)
-    ) {
-      return "Preorder release date and reservation must be provided together or both left empty.";
-    }
-    if (
-      (isReservation && !reservation_deposit_amount) ||
-      (!isReservation && reservation_deposit_amount)
-    ) {
-      return "Reservation deposit amount must be provided if reservation is true or both left empty.";
-    }
-    return true;
-  };
-
-  const handleInventoryTypeChange = (
-    e: React.ChangeEvent<HTMLSelectElement>,
-  ) => {
-    const newType = e.target.value as typeof inventoryType;
-    setInventoryType(newType);
-    setValue("inventory_type", newType);
-
-    // Reset related fields based on inventory type
-    if (newType === "infinite") {
-      setValue("inventory_quantity", null);
-      setValue("preorder_release_date", null);
-    } else if (newType === "preorder") {
-      setValue("inventory_quantity", null);
-      setIsReservation(false);
-      setValue("is_reservation", false);
-      setValue("reservation_deposit_amount", null);
-    } else if (newType === "finite") {
-      setValue("preorder_release_date", null);
-    }
-
-    // Trigger validation
-    trigger([
-      "inventory_quantity",
-      "preorder_release_date",
-      "is_reservation",
-      "reservation_deposit_amount",
-    ]);
-  };
-
   return (
     <RequireAuthentication>
       <Container className="max-w-xl">
         <Card>
           <CardHeader>
-            <Header title="List your robot for sale" />
+            <Header title="List your robot" />
           </CardHeader>
           <CardContent>
             <form
-              onSubmit={handleSubmit((data) => {
-                if (validateFields() !== true) {
-                  addErrorAlert(
-                    "Price amount and currency must be provided together or both left empty. Inventory quantity and type must be provided together or both left empty. Preorder release date and reservation must be provided together or both left empty. Reservation deposit amount must be provided if reservation is true or both left empty.",
-                  );
-                  return;
-                }
-                onSubmit(data);
-              })}
+              onSubmit={handleSubmit(onSubmit)}
               className="grid grid-cols-1 space-y-6"
             >
               {/* Name */}
               <div>
-                <label
-                  htmlFor="name"
-                  className="block mb-2 text-sm font-medium text-gray-1"
-                >
+                <label className="block mb-2 text-sm font-medium text-gray-1">
                   Name
                 </label>
                 <Input
-                  id="name"
                   placeholder="Name (at least 4 characters)"
                   type="text"
                   {...register("name")}
                 />
                 {errors?.name && (
-                  <ErrorMessage>{errors?.name?.message}</ErrorMessage>
+                  <ErrorMessage>{errors.name.message}</ErrorMessage>
+                )}
+                {previewUrl && (
+                  <div className="mt-3 text-sm">
+                    <p className="text-gray-1 font-medium">Preview URL:</p>
+                    <p className="text-gray-3 bg-gray-10 p-2 rounded-md">
+                      {previewUrl}
+                    </p>
+                  </div>
                 )}
               </div>
 
-              {/* Description Input */}
-              <div className="relative">
-                <label
-                  htmlFor="description"
-                  className="block mb-2 text-sm font-medium text-gray-1"
-                >
+              {/* Description */}
+              <div>
+                <label className="block mb-2 text-sm font-medium text-gray-1">
                   Description (supports Markdown formatting)
                 </label>
                 <TextArea
-                  id="description"
                   placeholder="Description (at least 6 characters)"
                   rows={4}
                   {...register("description", {
@@ -402,198 +233,132 @@ const CreateSell = () => {
                   })}
                 />
                 {errors?.description && (
-                  <ErrorMessage>{errors?.description?.message}</ErrorMessage>
+                  <ErrorMessage>{errors.description.message}</ErrorMessage>
                 )}
               </div>
 
-              {/* Render Description */}
+              {/* Description Preview */}
               {description && (
-                <div className="relative">
+                <div>
                   <h3 className="font-semibold mb-2">Description Preview</h3>
                   <RenderDescription description={description} />
                 </div>
               )}
 
-              {/* Slug */}
+              {/* Price */}
               <div>
-                <label
-                  htmlFor="slug"
-                  className="block mb-2 text-sm font-medium text-gray-1"
-                >
-                  Slug
+                <label className="block mb-2 text-sm font-medium text-gray-1">
+                  Price (USD)
                 </label>
                 <Input
-                  id="slug"
-                  placeholder="Unique identifier for your listing"
+                  placeholder="Enter price (e.g., 10.00)"
                   type="text"
-                  {...register("slug", {
-                    onChange: (e) => {
-                      const newSlug = slugify(e.target.value);
-                      setSlug(newSlug);
-                      setValue("slug", newSlug, { shouldValidate: true });
-                    },
-                  })}
-                  value={slug}
+                  value={displayPrice}
+                  onChange={handlePriceChange}
                 />
-                {errors?.slug && (
-                  <ErrorMessage>{errors?.slug?.message}</ErrorMessage>
+                {errors?.price_amount && (
+                  <ErrorMessage>{errors.price_amount.message}</ErrorMessage>
                 )}
               </div>
 
-              {/* URL Preview */}
-              {previewUrl && (
+              {/* Inventory Type */}
+              <div>
+                <label className="block mb-2 text-sm font-medium text-gray-1">
+                  Listing Type
+                </label>
+                <select
+                  className="w-full p-2 rounded-md border border-gray-7 bg-gray-3 text-gray-12"
+                  {...register("inventory_type")}
+                >
+                  <option value="finite">Limited Quantity</option>
+                  <option value="preorder">Pre-order</option>
+                </select>
+              </div>
+
+              {/* Quantity (for finite inventory) */}
+              {inventoryType === "finite" && (
                 <div>
                   <label className="block mb-2 text-sm font-medium text-gray-1">
-                    Listing URL Preview
+                    Available Quantity
                   </label>
-                  <div className="p-2 bg-gray-5 rounded-md text-gray-12">
-                    {previewUrl}
-                  </div>
+                  <Input
+                    type="number"
+                    min="1"
+                    {...register("inventory_quantity", { valueAsNumber: true })}
+                  />
+                  {errors?.inventory_quantity && (
+                    <ErrorMessage>
+                      {errors.inventory_quantity.message}
+                    </ErrorMessage>
+                  )}
                 </div>
               )}
 
-              {/* Payment Section */}
-              <div className="space-y-4 border-t border-gray-6 pt-4">
-                <h3 className="font-semibold text-lg">Payment Information</h3>
-
-                {/* Price */}
+              {/* Release Date (for pre-orders) */}
+              {inventoryType === "preorder" && (
                 <div>
-                  <label
-                    htmlFor="price"
-                    className="block mb-2 text-sm font-medium text-gray-1"
-                  >
-                    Price (USD)
+                  <label className="block mb-2 text-sm font-medium text-gray-1">
+                    Release Date
                   </label>
                   <Input
-                    id="price"
-                    placeholder="Enter price (e.g., 10.00)"
-                    type="text"
-                    value={displayPrice}
-                    onChange={handlePriceChange}
+                    type="date"
+                    min={new Date().toISOString().split("T")[0]}
+                    onChange={handleDateChange}
                   />
-                  {errors?.price_amount && (
-                    <ErrorMessage>{errors?.price_amount?.message}</ErrorMessage>
-                  )}
-                  {displayPrice && (
-                    <p className="mt-1 text-sm text-gray-9">
-                      Entered price: ${displayPrice}
-                    </p>
+                  {errors?.preorder_release_date && (
+                    <ErrorMessage>
+                      {errors.preorder_release_date.message}
+                    </ErrorMessage>
                   )}
                 </div>
+              )}
 
-                {/* Inventory Type */}
-                {price_amount && price_amount > 0 && (
-                  <div>
-                    <label className="block mb-2 text-sm font-medium text-gray-1">
-                      Inventory Type
-                    </label>
-                    <select
-                      className="w-full p-2 rounded-md border border-gray-7 bg-gray-3 text-gray-12"
-                      {...register("inventory_type")}
-                      onChange={handleInventoryTypeChange}
-                      value={inventoryType}
-                    >
-                      <option value="infinite">Unlimited</option>
-                      <option value="finite">Limited Quantity</option>
-                      <option value="preorder">Pre-order</option>
-                    </select>
-                  </div>
-                )}
-
-                {/* Finite Inventory Quantity */}
-                {inventoryType === "finite" && (
-                  <div>
-                    <label className="block mb-2 text-sm font-medium text-gray-1">
-                      Available Quantity
+              {/* Reservation Option */}
+              {price_amount &&
+                price_amount > 0 &&
+                inventoryType !== "preorder" && (
+                  <div className="space-y-4">
+                    <label className="flex items-center space-x-2">
+                      <input
+                        type="checkbox"
+                        {...register("is_reservation")}
+                        onChange={(e) => {
+                          setIsReservation(e.target.checked);
+                          setValue("is_reservation", e.target.checked);
+                        }}
+                        className="rounded border-gray-7"
+                      />
+                      <span className="text-sm font-medium text-gray-1">
+                        Enable Reservation
+                      </span>
                     </label>
-                    <Input
-                      type="number"
-                      min="1"
-                      onWheel={(e) => (e.target as HTMLInputElement).blur()} // prevent changing value when scrolling
-                      {...register("inventory_quantity", {
-                        valueAsNumber: true,
-                        validate: (value) =>
-                          (value && value > 0) ||
-                          "Quantity must be greater than 0",
-                      })}
-                    />
-                    {errors?.inventory_quantity && (
-                      <ErrorMessage>
-                        {errors?.inventory_quantity?.message}
-                      </ErrorMessage>
-                    )}
-                  </div>
-                )}
 
-                {/* Pre-order Release Date */}
-                {inventoryType === "preorder" && (
-                  <div>
-                    <label className="block mb-2 text-sm font-medium text-gray-1">
-                      Release Date
-                    </label>
-                    <Input
-                      type="date"
-                      min={new Date().toISOString().split("T")[0]}
-                      {...register("preorder_release_date", {
-                        setValueAs: (value) =>
-                          value ? new Date(value).getTime() / 1000 : null,
-                      })}
-                    />
-                    {errors?.preorder_release_date && (
-                      <ErrorMessage>
-                        {errors?.preorder_release_date?.message}
-                      </ErrorMessage>
+                    {isReservation && (
+                      <div>
+                        <label className="block mb-2 text-sm font-medium text-gray-1">
+                          Reservation Deposit Amount
+                        </label>
+                        <Input
+                          placeholder="Enter deposit amount"
+                          type="text"
+                          value={displayDepositAmount}
+                          onChange={handleDepositChange}
+                        />
+                        {errors?.reservation_deposit_amount && (
+                          <ErrorMessage>
+                            {errors?.reservation_deposit_amount?.message}
+                          </ErrorMessage>
+                        )}
+                        {displayDepositAmount && (
+                          <p className="mt-1 text-sm text-gray-11">
+                            Deposit amount: ${displayDepositAmount}
+                          </p>
+                        )}
+                      </div>
                     )}
                   </div>
                 )}
 
-                {/* Reservation Option */}
-                {price_amount &&
-                  price_amount > 0 &&
-                  inventoryType !== "preorder" && (
-                    <div className="space-y-4">
-                      <label className="flex items-center space-x-2">
-                        <input
-                          type="checkbox"
-                          {...register("is_reservation")}
-                          onChange={(e) => {
-                            setIsReservation(e.target.checked);
-                            setValue("is_reservation", e.target.checked);
-                          }}
-                          className="rounded border-gray-7"
-                        />
-                        <span className="text-sm font-medium text-gray-1">
-                          Enable Reservation
-                        </span>
-                      </label>
-
-                      {isReservation && (
-                        <div>
-                          <label className="block mb-2 text-sm font-medium text-gray-1">
-                            Reservation Deposit Amount
-                          </label>
-                          <Input
-                            placeholder="Enter deposit amount"
-                            type="text"
-                            value={displayDepositAmount}
-                            onChange={handleDepositChange}
-                          />
-                          {errors?.reservation_deposit_amount && (
-                            <ErrorMessage>
-                              {errors?.reservation_deposit_amount?.message}
-                            </ErrorMessage>
-                          )}
-                          {displayDepositAmount && (
-                            <p className="mt-1 text-sm text-gray-11">
-                              Deposit amount: ${displayDepositAmount}
-                            </p>
-                          )}
-                        </div>
-                      )}
-                    </div>
-                  )}
-              </div>
-
               {/* Photos */}
               <div>
                 <label className="block mb-2 text-sm font-medium text-gray-1">
diff --git a/frontend/src/components/stripe/CheckoutButton.tsx b/frontend/src/components/stripe/CheckoutButton.tsx
index 7ff4cbaf..1c226e28 100644
--- a/frontend/src/components/stripe/CheckoutButton.tsx
+++ b/frontend/src/components/stripe/CheckoutButton.tsx
@@ -11,8 +11,6 @@ import { ApiError } from "@/lib/types/api";
 import ROUTES from "@/lib/types/routes";
 import { loadStripe } from "@stripe/stripe-js";
 
-const stripePromise = loadStripe(STRIPE_PUBLISHABLE_KEY);
-
 interface Props {
   listingId: string;
   stripeProductId: string;
@@ -39,7 +37,12 @@ const CheckoutButton: React.FC<Props> = ({
     inventoryType === "finite" &&
     (inventoryQuantity === undefined || inventoryQuantity <= 0);
 
-  const buttonLabel = isOutOfStock ? "Out of Stock" : label;
+  const buttonLabel =
+    inventoryType === "preorder"
+      ? "Pre-order Now"
+      : isOutOfStock
+        ? "Out of Stock"
+        : label;
 
   const handleClick = async () => {
     setIsLoading(true);
@@ -50,26 +53,6 @@ const CheckoutButton: React.FC<Props> = ({
       return;
     }
 
-    if (!stripePromise) {
-      console.error("Stripe configuration is missing");
-      addErrorAlert(
-        "Payment system is not properly configured. Please contact support.",
-      );
-      setIsLoading(false);
-      return;
-    }
-
-    const stripe = await stripePromise;
-
-    if (!stripe) {
-      console.error("Failed to initialize Stripe");
-      addErrorAlert(
-        "Unable to process payment at this time. Please try again later.",
-      );
-      setIsLoading(false);
-      return;
-    }
-
     try {
       const { data, error } = await auth.client.POST(
         "/stripe/create-checkout-session",
@@ -88,12 +71,23 @@ const CheckoutButton: React.FC<Props> = ({
         return;
       }
 
-      if (!data || !data.session_id) {
+      if (!data || !data.session_id || !data.stripe_connect_account_id) {
         throw new Error("Invalid response from server");
       }
 
+      console.log(data.stripe_connect_account_id);
+
+      // Initialize Stripe with the connected account
+      const stripeWithAccount = await loadStripe(STRIPE_PUBLISHABLE_KEY, {
+        stripeAccount: data.stripe_connect_account_id,
+      });
+
+      if (!stripeWithAccount) {
+        throw new Error("Failed to initialize Stripe");
+      }
+
       // Redirect to Stripe Checkout
-      const result = await stripe.redirectToCheckout({
+      const result = await stripeWithAccount.redirectToCheckout({
         sessionId: data.session_id,
       });
 
diff --git a/frontend/src/gen/api.ts b/frontend/src/gen/api.ts
index 66ceaa0c..7623e5e0 100644
--- a/frontend/src/gen/api.ts
+++ b/frontend/src/gen/api.ts
@@ -1033,6 +1033,23 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/stripe/process-preorder/{order_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Process Preorder */
+        post: operations["process_preorder_stripe_process_preorder__order_id__post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/users/me": {
         parameters: {
             query?: never;
@@ -1291,7 +1308,7 @@ export interface components {
             /** Slug */
             slug: string;
             /** Price Amount */
-            price_amount?: number | null;
+            price_amount?: string | null;
             /**
              * Currency
              * @default usd
@@ -1299,21 +1316,21 @@ export interface components {
             currency: string;
             /**
              * Inventory Type
-             * @default infinite
+             * @default finite
              * @enum {string}
              */
-            inventory_type: "finite" | "infinite" | "preorder";
+            inventory_type: "finite" | "preorder";
             /** Inventory Quantity */
-            inventory_quantity?: number | null;
+            inventory_quantity?: string | null;
             /** Preorder Release Date */
-            preorder_release_date?: number | null;
+            preorder_release_date?: string | null;
             /**
              * Is Reservation
              * @default false
              */
             is_reservation: boolean;
             /** Reservation Deposit Amount */
-            reservation_deposit_amount?: number | null;
+            reservation_deposit_amount?: string | null;
             /** Photos */
             photos?: string[];
         };
@@ -1386,6 +1403,8 @@ export interface components {
         CreateCheckoutSessionResponse: {
             /** Session Id */
             session_id: string;
+            /** Stripe Connect Account Id */
+            stripe_connect_account_id: string;
         };
         /** CreateConnectAccountResponse */
         CreateConnectAccountResponse: {
@@ -1732,10 +1751,6 @@ export interface components {
             user_id: string;
             /** User Email */
             user_email: string;
-            /** Stripe Checkout Session Id */
-            stripe_checkout_session_id: string;
-            /** Stripe Payment Intent Id */
-            stripe_payment_intent_id: string;
             /** Created At */
             created_at: number;
             /** Updated At */
@@ -1751,8 +1766,18 @@ export interface components {
             currency: string;
             /** Quantity */
             quantity: number;
+            /** Stripe Checkout Session Id */
+            stripe_checkout_session_id: string;
             /** Stripe Product Id */
             stripe_product_id: string;
+            /** Stripe Connect Account Id */
+            stripe_connect_account_id: string;
+            /** Stripe Customer Id */
+            stripe_customer_id?: string | null;
+            /** Stripe Payment Method Id */
+            stripe_payment_method_id?: string | null;
+            /** Stripe Payment Intent Id */
+            stripe_payment_intent_id?: string | null;
             /** Stripe Refund Id */
             stripe_refund_id?: string | null;
             /** Shipping Name */
@@ -3897,6 +3922,37 @@ export interface operations {
             };
         };
     };
+    process_preorder_stripe_process_preorder__order_id__post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                order_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": Record<string, never>;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     get_user_info_endpoint_users_me_get: {
         parameters: {
             query?: never;
diff --git a/frontend/src/lib/types/index.ts b/frontend/src/lib/types/index.ts
index 576da60d..d166fa87 100644
--- a/frontend/src/lib/types/index.ts
+++ b/frontend/src/lib/types/index.ts
@@ -90,9 +90,7 @@ export const ShareListingSchema = BaseListingSchema;
 export const SellListingSchema = BaseListingSchema.extend({
   price_amount: z.number().nullable(),
   currency: z.string().default("usd"),
-  inventory_type: z
-    .enum(["finite", "infinite", "preorder"])
-    .default("infinite"),
+  inventory_type: z.enum(["finite", "preorder"]).default("finite"),
   inventory_quantity: z.number().nullable(),
   preorder_release_date: z.number().nullable(),
   is_reservation: z.boolean().default(false),
diff --git a/store/app/model.py b/store/app/model.py
index fa1aafd4..c3b82959 100644
--- a/store/app/model.py
+++ b/store/app/model.py
@@ -51,6 +51,7 @@ class User(StoreBaseModel):
     last_name: str | None = None
     name: str | None = None
     bio: str | None = None
+    stripe_customer_ids: dict[str, str] = {}
     stripe_connect_account_id: str | None = None
     stripe_connect_onboarding_completed: bool = False
 
@@ -66,6 +67,7 @@ def create(
         last_name: str | None = None,
         name: str | None = None,
         bio: str | None = None,
+        stripe_customer_ids: dict[str, str] = {},
         stripe_connect_account_id: str | None = None,
         stripe_connect_onboarding_completed: bool = False,
     ) -> Self:
@@ -84,6 +86,7 @@ def create(
             last_name=last_name,
             name=name,
             bio=bio,
+            stripe_customer_ids=stripe_customer_ids,
             stripe_connect_account_id=stripe_connect_account_id,
             stripe_connect_onboarding_completed=stripe_connect_onboarding_completed,
         )
@@ -585,15 +588,18 @@ class Order(StoreBaseModel):
 
     user_id: str
     user_email: str
-    stripe_checkout_session_id: str
-    stripe_payment_intent_id: str
     created_at: int
     updated_at: int
     status: OrderStatus
     amount: int
     currency: str
     quantity: int
+    stripe_checkout_session_id: str
     stripe_product_id: str
+    stripe_connect_account_id: str
+    stripe_customer_id: str | None = None
+    stripe_payment_method_id: str | None = None
+    stripe_payment_intent_id: str | None = None
     stripe_refund_id: str | None = None
     shipping_name: str | None = None
     shipping_address_line1: str | None = None
@@ -608,12 +614,15 @@ def create(
         cls,
         user_id: str,
         user_email: str,
-        stripe_checkout_session_id: str,
-        stripe_payment_intent_id: str,
         amount: int,
         currency: str,
         quantity: int,
+        stripe_checkout_session_id: str,
         stripe_product_id: str,
+        stripe_connect_account_id: str,
+        stripe_customer_id: str | None = None,
+        stripe_payment_method_id: str | None = None,
+        stripe_payment_intent_id: str | None = None,
         stripe_refund_id: str | None = None,
         status: OrderStatus = "processing",
         shipping_name: str | None = None,
@@ -629,15 +638,18 @@ def create(
             id=new_uuid(),
             user_id=user_id,
             user_email=user_email,
-            stripe_checkout_session_id=stripe_checkout_session_id,
-            stripe_payment_intent_id=stripe_payment_intent_id,
             created_at=now,
             updated_at=now,
             status=status,
             amount=amount,
             currency=currency,
             quantity=quantity,
+            stripe_checkout_session_id=stripe_checkout_session_id,
             stripe_product_id=stripe_product_id,
+            stripe_connect_account_id=stripe_connect_account_id,
+            stripe_customer_id=stripe_customer_id,
+            stripe_payment_method_id=stripe_payment_method_id,
+            stripe_payment_intent_id=stripe_payment_intent_id,
             stripe_refund_id=stripe_refund_id,
             shipping_name=shipping_name,
             shipping_address_line1=shipping_address_line1,
diff --git a/store/app/routers/listings.py b/store/app/routers/listings.py
index 7b004de3..f86fcd6b 100644
--- a/store/app/routers/listings.py
+++ b/store/app/routers/listings.py
@@ -277,33 +277,31 @@ async def add_listing(
     description: str | None = Form(None),
     child_ids: str = Form(""),
     slug: str = Form(...),
-    price_amount: int | None = Form(None),
+    price_amount: str | None = Form(None),
     currency: str = Form("usd"),
-    inventory_type: Literal["finite", "infinite", "preorder"] = Form("infinite"),
-    inventory_quantity: int | None = Form(None),
-    preorder_release_date: int | None = Form(None),
+    inventory_type: Literal["finite", "preorder"] = Form("finite"),
+    inventory_quantity: str | None = Form(None),
+    preorder_release_date: str | None = Form(None),
     is_reservation: bool = Form(False),
-    reservation_deposit_amount: int | None = Form(None),
+    reservation_deposit_amount: str | None = Form(None),
     photos: List[UploadFile] = File(None),
 ) -> NewListingResponse:
     try:
         logger.info("Starting to process add listing request")
 
-        # Initialize variables
+        # Convert string values to appropriate types
+        price_amount_int = int(price_amount) if price_amount else None
+        inventory_quantity_int = int(inventory_quantity) if inventory_quantity else None
+        preorder_release_date_int = int(float(preorder_release_date)) if preorder_release_date else None
+        reservation_deposit_amount_int = int(reservation_deposit_amount) if reservation_deposit_amount else None
+
+        # Initialize Stripe-related variables
         stripe_product_id = None
         stripe_price_id = None
-        deposit_price_id = None  # Initialize here
-
-        # Validation checks
-        if price_amount is not None and price_amount <= 0:
-            logger.error("Validation failed: Price amount must be greater than 0")
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Price amount must be greater than 0",
-            )
+        deposit_price_id = None
 
         # Create Stripe product if price is set
-        if price_amount is not None and user.stripe_connect_account_id:
+        if price_amount_int is not None and user.stripe_connect_account_id:
             try:
                 product = stripe.Product.create(
                     name=name,
@@ -313,31 +311,30 @@ async def add_listing(
                     },
                     stripe_account=user.stripe_connect_account_id,
                 )
+                stripe_product_id = product.id
 
                 price = stripe.Price.create(
                     product=product.id,
                     currency=currency,
-                    unit_amount=price_amount,
+                    unit_amount=price_amount_int,
                     metadata={
-                        "inventory_quantity": str(inventory_quantity) if inventory_type == "finite" else "",
-                        "preorder_release_date": str(preorder_release_date) if inventory_type == "preorder" else "",
+                        "inventory_quantity": str(inventory_quantity_int) if inventory_type == "finite" else "",
+                        "preorder_release_date": str(preorder_release_date_int) if inventory_type == "preorder" else "",
                     },
                     stripe_account=user.stripe_connect_account_id,
                 )
+                stripe_price_id = price.id
 
-                if is_reservation and reservation_deposit_amount:
+                if is_reservation and reservation_deposit_amount_int:
                     deposit_price = stripe.Price.create(
                         product=product.id,
                         currency=currency,
-                        unit_amount=reservation_deposit_amount,
+                        unit_amount=reservation_deposit_amount_int,
                         metadata={"is_deposit": "true"},
                         stripe_account=user.stripe_connect_account_id,
                     )
                     deposit_price_id = deposit_price.id
 
-                stripe_product_id = product.id
-                stripe_price_id = price.id
-
             except stripe.StripeError as e:
                 logger.error(f"Stripe error: {str(e)}")
                 raise HTTPException(
@@ -352,13 +349,13 @@ async def add_listing(
             child_ids=child_ids.split(",") if child_ids else [],
             slug=slug,
             user_id=user.id,
-            price_amount=price_amount,
+            price_amount=price_amount_int,
             currency=currency,
             inventory_type=inventory_type,
-            inventory_quantity=inventory_quantity,
-            preorder_release_date=preorder_release_date,
+            inventory_quantity=inventory_quantity_int,
+            preorder_release_date=preorder_release_date_int,
             is_reservation=is_reservation,
-            reservation_deposit_amount=reservation_deposit_amount,
+            reservation_deposit_amount=reservation_deposit_amount_int,
             stripe_product_id=stripe_product_id,
             stripe_price_id=stripe_price_id,
             stripe_deposit_price_id=deposit_price_id,
diff --git a/store/app/routers/stripe.py b/store/app/routers/stripe.py
index d1351bc7..8295a67f 100644
--- a/store/app/routers/stripe.py
+++ b/store/app/routers/stripe.py
@@ -1,6 +1,7 @@
 """Stripe integration router for handling payments and webhooks."""
 
 import logging
+from datetime import datetime
 from enum import Enum
 from typing import Annotated, Any, Dict, Literal
 
@@ -11,6 +12,7 @@
 from store.app.db import Crud
 from store.app.model import Order, User
 from store.app.security.user import (
+    get_session_user_with_admin_permission,
     get_session_user_with_read_permission,
     get_session_user_with_write_permission,
 )
@@ -132,7 +134,86 @@ async def stripe_webhook(request: Request, crud: Crud = Depends(Crud.get)) -> Di
 
         elif event["type"] == "checkout.session.completed":
             session = event["data"]["object"]
-            await handle_checkout_session_completed(session, crud)
+
+            # Handle setup completion for preorders
+            if session["mode"] == "setup":
+                try:
+                    seller_connect_account_id = session["metadata"].get("seller_connect_account_id")
+                    if not seller_connect_account_id:
+                        raise ValueError("Missing seller connect account ID")
+
+                    # Get the customer ID from the session
+                    connected_customer_id = session["metadata"].get("connected_customer_id")
+
+                    # Retrieve SetupIntent with expanded payment method
+                    setup_intent = stripe.SetupIntent.retrieve(
+                        session["setup_intent"],
+                        expand=["payment_method"],
+                        stripe_account=seller_connect_account_id,
+                    )
+
+                    if not setup_intent.payment_method or isinstance(setup_intent.payment_method, str):
+                        raise ValueError("Invalid payment method")
+
+                    # Attach the payment method to the customer
+                    stripe.PaymentMethod.attach(
+                        setup_intent.payment_method.id,
+                        customer=connected_customer_id,
+                        stripe_account=seller_connect_account_id,
+                    )
+
+                    # Set as default payment method for the customer
+                    stripe.Customer.modify(
+                        connected_customer_id,
+                        invoice_settings={"default_payment_method": setup_intent.payment_method.id},
+                        stripe_account=seller_connect_account_id,
+                    )
+
+                    # Create order for preorder
+                    order_data = {
+                        "user_id": session["client_reference_id"],
+                        "user_email": session["customer_details"]["email"],
+                        "stripe_checkout_session_id": session["id"],
+                        "stripe_payment_intent_id": None,
+                        "amount": int(session["metadata"]["price_amount"]),
+                        "currency": "usd",
+                        "status": "processing",
+                        "quantity": 1,
+                        "stripe_product_id": session["metadata"].get("stripe_product_id"),
+                        "stripe_customer_id": connected_customer_id,
+                        "stripe_payment_method_id": setup_intent.payment_method.id,
+                        "stripe_connect_account_id": seller_connect_account_id,
+                    }
+
+                    # Add shipping details if available
+                    if shipping_details := session.get("shipping_details"):
+                        shipping_address = shipping_details.get("address", {})
+                        order_data.update(
+                            {
+                                "shipping_name": shipping_details.get("name"),
+                                "shipping_address_line1": shipping_address.get("line1"),
+                                "shipping_address_line2": shipping_address.get("line2"),
+                                "shipping_city": shipping_address.get("city"),
+                                "shipping_state": shipping_address.get("state"),
+                                "shipping_postal_code": shipping_address.get("postal_code"),
+                                "shipping_country": shipping_address.get("country"),
+                            }
+                        )
+
+                    await crud.create_order(order_data)
+                    logger.info(
+                        "Successfully processed preorder setup for customer %s with payment method %s",
+                        connected_customer_id,
+                        setup_intent.payment_method.id,
+                    )
+
+                except Exception as e:
+                    logger.error("Error processing preorder webhook: %s", str(e))
+                    raise
+
+            else:
+                # Handle regular checkout completion
+                await handle_checkout_session_completed(session, crud)
         elif event["type"] == "payment_intent.succeeded":
             payment_intent = event["data"]["object"]
             logger.info("Payment intent succeeded: %s", payment_intent["id"])
@@ -141,6 +222,9 @@ async def stripe_webhook(request: Request, crud: Crud = Depends(Crud.get)) -> Di
     except ValueError as e:
         logger.error("Invalid payload: %s", str(e))
         raise HTTPException(status_code=400, detail="Invalid payload")
+    except Exception as e:
+        logger.error("Error processing webhook: %s", str(e))
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 async def handle_checkout_session_completed(session: Dict[str, Any], crud: Crud) -> None:
@@ -237,6 +321,7 @@ class CreateCheckoutSessionRequest(BaseModel):
 
 class CreateCheckoutSessionResponse(BaseModel):
     session_id: str
+    stripe_connect_account_id: str
 
 
 @router.post("/create-checkout-session", response_model=CreateCheckoutSessionResponse)
@@ -253,16 +338,6 @@ async def create_checkout_session(
                 logger.error(f"Listing not found or has no price: {request.listing_id}")
                 raise HTTPException(status_code=404, detail="Listing not found or has no price")
 
-            # Validate inventory
-            if listing.inventory_type == "finite":
-                if listing.inventory_quantity is None:
-                    raise HTTPException(status_code=400, detail="Invalid inventory configuration")
-                if listing.inventory_quantity <= 0:
-                    raise HTTPException(status_code=400, detail="This item is out of stock")
-
-            if not listing.stripe_price_id:
-                raise HTTPException(status_code=400, detail="Listing has no associated Stripe price")
-
             # Get seller details
             seller = await crud.get_user(listing.user_id)
             if not seller or not seller.stripe_connect_account_id:
@@ -272,74 +347,140 @@ async def create_checkout_session(
             if seller.id == user.id:
                 raise HTTPException(status_code=400, detail="You cannot purchase your own listing")
 
+            # Get or create customer on the connected account
+            connected_customer_id = user.stripe_customer_ids.get(seller.stripe_connect_account_id)
+
+            if not connected_customer_id:
+                # Create new customer on connected account
+                connected_customer = stripe.Customer.create(
+                    email=user.email,
+                    metadata={"user_id": user.id},
+                    stripe_account=seller.stripe_connect_account_id,
+                )
+                connected_customer_id = connected_customer.id
+
+                # Update user's stripe_customer_ids map
+                stripe_customer_ids = dict(user.stripe_customer_ids)
+                stripe_customer_ids[seller.stripe_connect_account_id] = connected_customer_id
+                await crud.update_user(user.id, {"stripe_customer_ids": stripe_customer_ids})
+                user.stripe_customer_ids = stripe_customer_ids
+
             # Calculate maximum quantity
             max_quantity = 10
             if listing.inventory_type == "finite" and listing.inventory_quantity is not None:
                 max_quantity = min(listing.inventory_quantity, 10)
 
-            application_fee = int(listing.price_amount * 0.02)  # 2% fee for our platform
-
-            # Create a clone of the price on the platform account
-            platform_price = stripe.Price.create(
-                unit_amount=listing.price_amount,
-                currency="usd",
-                product_data={
-                    "name": listing.name,
-                    "metadata": {
-                        "original_price_id": listing.stripe_price_id,
-                        "seller_connect_account_id": seller.stripe_connect_account_id,
-                    },
-                },
-            )
+            # Determine payment methods based on listing type and price
+            payment_methods: list[str] = ["card"]
+            if listing.price_amount >= 5000 and listing.inventory_type != "preorder":
+                payment_methods.append("affirm")
 
-            metadata: dict[str, str] = {
-                "user_email": user.email,
-                "product_id": listing.stripe_product_id or "",
-            }
             if listing.stripe_product_id:
-                metadata["stripe_product_id"] = listing.stripe_product_id
+                metadata: dict[str, str] = {
+                    "user_email": user.email,
+                    "product_id": listing.stripe_product_id,
+                    "listing_type": listing.inventory_type,
+                    "stripe_product_id": listing.stripe_product_id,
+                    "connected_customer_id": connected_customer_id,
+                }
+
+            # Base checkout session parameters
+            checkout_params: dict[str, Any] = {
+                "mode": "payment",
+                "customer_email": user.email,
+                "payment_method_types": payment_methods,
+                "success_url": f"{settings.site.homepage}/order/success?session_id={{CHECKOUT_SESSION_ID}}",
+                "cancel_url": f"{settings.site.homepage}{request.cancel_url}",
+                "client_reference_id": user.id,
+                "shipping_address_collection": {"allowed_countries": ["US"]},
+                "metadata": metadata,
+            }
 
-            checkout_session = stripe.checkout.Session.create(
-                line_items=[
+            # For preorders, use setup mode
+            if listing.inventory_type == "preorder":
+                checkout_params.update(
                     {
-                        "price": platform_price.id,
-                        "quantity": 1,
-                        **(
+                        "mode": "setup",
+                        "metadata": {
+                            **metadata,
+                            "listing_id": listing.id,
+                            "price_amount": str(listing.price_amount),
+                            "seller_connect_account_id": seller.stripe_connect_account_id,
+                        },
+                        "setup_intent_data": {
+                            "metadata": {
+                                "user_id": user.id,
+                                "listing_id": listing.id,
+                            }
+                        },
+                    }
+                )
+
+                # Add custom text for preorder explanation
+                if listing.preorder_release_date:
+                    formatted_date = datetime.fromtimestamp(listing.preorder_release_date).strftime("%B %d, %Y")
+                    checkout_params["custom_text"] = {
+                        "submit": {
+                            "message": (
+                                "By placing this pre-order, you agree to save your payment method. "
+                                f"You will be charged ${listing.price_amount/100:,.2f} when the item is ready "
+                                f"to ship (estimated {formatted_date})."
+                            )
+                        }
+                    }
+            else:
+                # Regular payment mode
+                if not listing.stripe_price_id and listing.stripe_product_id:
+                    # Create a new price if one doesn't exist
+                    price = stripe.Price.create(
+                        unit_amount=listing.price_amount,
+                        currency=listing.currency or "usd",
+                        product=listing.stripe_product_id,
+                        metadata={"listing_id": listing.id},
+                        stripe_account=seller.stripe_connect_account_id,
+                    )
+                    # Update the listing with the new price ID
+                    await crud.edit_listing(listing_id=listing.id, stripe_price_id=price.id)
+                    listing.stripe_price_id = price.id
+
+                # Calculate application fee
+                application_fee = int(listing.price_amount * 0.02)  # 2% fee
+
+                checkout_params.update(
+                    {
+                        "line_items": [
                             {
-                                "adjustable_quantity": {
-                                    "enabled": True,
-                                    "minimum": 1,
-                                    "maximum": max_quantity,
-                                }
+                                "price": listing.stripe_price_id,
+                                "quantity": 1,
+                                **(
+                                    {"adjustable_quantity": {"enabled": True, "minimum": 1, "maximum": max_quantity}}
+                                    if max_quantity > 1
+                                    else {}
+                                ),
                             }
-                            if max_quantity > 1
-                            else {}
-                        ),
+                        ],
+                        "payment_intent_data": {
+                            "application_fee_amount": application_fee,
+                            "transfer_data": {
+                                "destination": seller.stripe_connect_account_id,
+                            },
+                        },
                     }
-                ],
-                mode="payment",
-                payment_method_types=(["card", "affirm"] if listing.price_amount >= 5000 else ["card"]),
-                success_url=f"{settings.site.homepage}/order/success?session_id={{CHECKOUT_SESSION_ID}}",
-                cancel_url=f"{settings.site.homepage}{request.cancel_url}",
-                client_reference_id=user.id,
-                metadata=metadata,
-                shipping_address_collection={"allowed_countries": ["US", "CA"]},
-                payment_intent_data={
-                    "application_fee_amount": application_fee,
-                    "transfer_data": {
-                        "destination": seller.stripe_connect_account_id,
-                    },
-                },
+                )
+
+            # Create the checkout session on the connected account
+            checkout_session = stripe.checkout.Session.create(
+                **checkout_params,
+                stripe_account=seller.stripe_connect_account_id,
             )
 
-            return CreateCheckoutSessionResponse(session_id=checkout_session.id)
+            return CreateCheckoutSessionResponse(
+                session_id=checkout_session.id, stripe_connect_account_id=seller.stripe_connect_account_id
+            )
 
         except stripe.StripeError as e:
             logger.error(f"Stripe error: {str(e)}", exc_info=True)
             raise HTTPException(status_code=400, detail=str(e))
-        except Exception as e:
-            logger.error(f"Unexpected error: {str(e)}", exc_info=True)
-            raise HTTPException(status_code=400, detail=str(e))
 
 
 @router.get("/get-product/{product_id}")
@@ -379,7 +520,7 @@ class CreateConnectAccountResponse(BaseModel):
 
 @router.post("/connect/account", response_model=CreateConnectAccountResponse)
 async def create_connect_account(
-    user: Annotated[User, Depends(get_session_user_with_read_permission)],
+    user: Annotated[User, Depends(get_session_user_with_write_permission)],
     crud: Annotated[Crud, Depends(Crud.get)],
 ) -> CreateConnectAccountResponse:
     try:
@@ -543,3 +684,58 @@ async def create_stripe_product(
     except stripe.StripeError as e:
         logger.error(f"Stripe error: {str(e)}")
         raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/process-preorder/{order_id}")
+async def process_preorder(
+    order_id: str,
+    user: User = Depends(get_session_user_with_admin_permission),
+    crud: Crud = Depends(),
+) -> Dict[str, Any]:
+    async with crud:
+        try:
+            order = await crud.get_order(order_id)
+            if not order or not order.stripe_customer_id or not order.stripe_payment_method_id:
+                raise HTTPException(status_code=404, detail="Order not found or missing payment details")
+
+            # Get the listing and seller info
+            listing = await crud.get_listing_by_stripe_product_id(order.stripe_product_id)
+            if not listing:
+                raise HTTPException(status_code=404, detail="Listing not found")
+
+            seller = await crud.get_user(listing.user_id)
+            if not seller or not seller.stripe_connect_account_id:
+                raise HTTPException(status_code=400, detail="Seller not found or not connected to Stripe")
+
+            # Calculate platform fee
+            application_fee = int(order.amount * 0.02)  # 2% fee
+
+            # Create and confirm payment intent using the stored payment method
+            payment_intent = stripe.PaymentIntent.create(
+                amount=order.amount,
+                currency=order.currency,
+                customer=order.stripe_customer_id,
+                payment_method=order.stripe_payment_method_id,
+                off_session=True,
+                confirm=True,
+                application_fee_amount=application_fee,
+                transfer_data={
+                    "destination": seller.stripe_connect_account_id,
+                },
+                stripe_account=seller.stripe_connect_account_id,
+            )
+
+            # Update order status
+            await crud.update_order(
+                order_id,
+                {
+                    "status": "processing",
+                    "stripe_payment_intent_id": payment_intent.id,
+                },
+            )
+
+            return {"status": "success", "payment_intent_id": payment_intent.id}
+
+        except stripe.StripeError as e:
+            logger.error(f"Stripe error processing preorder: {str(e)}")
+            raise HTTPException(status_code=400, detail=str(e))