diff --git a/apps/web/components/booking/CancelBooking.tsx b/apps/web/components/booking/CancelBooking.tsx
index bd57791e52f61c..4591aa92b54cb8 100644
--- a/apps/web/components/booking/CancelBooking.tsx
+++ b/apps/web/components/booking/CancelBooking.tsx
@@ -6,10 +6,11 @@ import { sdkActionManager } from "@calcom/embed-core/embed-iframe";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
 import { useRefreshData } from "@calcom/lib/hooks/useRefreshData";
 import { useTelemetry } from "@calcom/lib/hooks/useTelemetry";
+import { shouldChargeNoShowCancellationFee } from "@calcom/lib/payment/shouldChargeNoShowCancellationFee";
 import { collectPageParameters, telemetryEventTypes } from "@calcom/lib/telemetry";
 import type { RecurringEvent } from "@calcom/types/Calendar";
 import { Button } from "@calcom/ui/components/button";
-import { Label, Select, TextArea } from "@calcom/ui/components/form";
+import { Label, Select, TextArea, CheckboxField } from "@calcom/ui/components/form";
 import { Icon } from "@calcom/ui/components/icon";
 
 interface InternalNotePresetsSelectProps {
@@ -76,6 +77,12 @@ type Props = {
     title?: string;
     uid?: string;
     id?: number;
+    startTime: Date;
+    payment?: {
+      amount: number;
+      currency: string;
+      appId: string | null;
+    } | null;
   };
   profile: {
     name: string | null;
@@ -100,6 +107,7 @@ type Props = {
   };
   isHost: boolean;
   internalNotePresets: { id: number; name: string; cancellationReason: string | null }[];
+  eventTypeMetadata?: Record<string, unknown> | null;
 };
 
 export default function CancelBooking(props: Props) {
@@ -112,13 +120,48 @@ export default function CancelBooking(props: Props) {
     seatReferenceUid,
     bookingCancelledEventProps,
     currentUserEmail,
-    teamId,
+    eventTypeMetadata,
   } = props;
   const [loading, setLoading] = useState(false);
   const telemetry = useTelemetry();
   const [error, setError] = useState<string | null>(booking ? null : t("booking_already_cancelled"));
   const [internalNote, setInternalNote] = useState<{ id: number; name: string } | null>(null);
+  const [acknowledgeCancellationNoShowFee, setAcknowledgeCancellationNoShowFee] = useState(false);
 
+  const getAppMetadata = (appId: string): Record<string, unknown> | null => {
+    if (!eventTypeMetadata?.apps || !appId) return null;
+    const apps = eventTypeMetadata.apps as Record<string, unknown>;
+    return (apps[appId] as Record<string, unknown>) || null;
+  };
+
+  const timeValue = booking?.payment?.appId
+    ? (getAppMetadata(booking.payment.appId) as Record<string, unknown> | null)?.autoChargeNoShowFeeTimeValue
+    : null;
+  const timeUnit = booking?.payment?.appId
+    ? (getAppMetadata(booking.payment.appId) as Record<string, unknown> | null)?.autoChargeNoShowFeeTimeUnit
+    : null;
+
+  const autoChargeNoShowFee = () => {
+    if (props.isHost) return false; // Hosts/organizers are exempt
+
+    if (!booking?.startTime) return false;
+
+    if (!booking?.payment) return false;
+
+    return shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: eventTypeMetadata || null,
+      booking,
+      payment: booking.payment,
+    });
+  };
+
+  const cancellationNoShowFeeWarning = autoChargeNoShowFee();
+
+  const hostMissingCancellationReason =
+    props.isHost &&
+    (!cancellationReason?.trim() || (props.internalNotePresets.length > 0 && !internalNote?.id));
+  const cancellationNoShowFeeNotAcknowledged =
+    !props.isHost && cancellationNoShowFeeWarning && !acknowledgeCancellationNoShowFee;
   const cancelBookingRef = useCallback((node: HTMLTextAreaElement) => {
     if (node !== null) {
       // eslint-disable-next-line @calcom/eslint/no-scroll-into-view-embed -- CancelBooking is not usually used in embed mode
@@ -187,6 +230,23 @@ export default function CancelBooking(props: Props) {
               </p>
             </div>
           ) : null}
+          {cancellationNoShowFeeWarning && booking?.payment && (
+            <div>
+              <div className="bg-attention mb-5 rounded-md p-3">
+                <CheckboxField
+                  description={t("cancel_booking_acknowledge_no_show_fee", {
+                    timeValue,
+                    timeUnit,
+                    amount: booking.payment.amount / 100,
+                    formatParams: { amount: { currency: booking.payment.currency } },
+                  })}
+                  onChange={(e) => setAcknowledgeCancellationNoShowFee(e.target.checked)}
+                  descriptionClassName="text-info font-semibold"
+                />
+                <p className="text-subtle ml-9 mt-2 text-sm">{t("contact_organizer")}</p>
+              </div>
+            </div>
+          )}
           <div className="flex flex-col-reverse rtl:space-x-reverse ">
             <div className="ml-auto flex w-full space-x-4 ">
               <Button
@@ -197,10 +257,7 @@ export default function CancelBooking(props: Props) {
               </Button>
               <Button
                 data-testid="confirm_cancel"
-                disabled={
-                  props.isHost &&
-                  (!cancellationReason?.trim() || (props.internalNotePresets.length > 0 && !internalNote?.id))
-                }
+                disabled={hostMissingCancellationReason || cancellationNoShowFeeNotAcknowledged}
                 onClick={async () => {
                   setLoading(true);
 
diff --git a/apps/web/components/booking/__tests__/CancelBooking.cancellationFee.test.tsx b/apps/web/components/booking/__tests__/CancelBooking.cancellationFee.test.tsx
new file mode 100644
index 00000000000000..39f09e4befbdbb
--- /dev/null
+++ b/apps/web/components/booking/__tests__/CancelBooking.cancellationFee.test.tsx
@@ -0,0 +1,257 @@
+import { render, screen } from "@testing-library/react";
+import * as React from "react";
+import { describe, expect, it, vi, beforeAll } from "vitest";
+
+import * as shouldChargeModule from "@calcom/lib/payment/shouldChargeNoShowCancellationFee";
+
+import CancelBooking from "../CancelBooking";
+
+beforeAll(() => {
+  Element.prototype.scrollIntoView = vi.fn();
+});
+
+vi.mock("@calcom/trpc", () => ({
+  trpc: {
+    viewer: {
+      bookings: {
+        requestReschedule: {
+          useMutation: () => ({
+            mutate: vi.fn(),
+            isLoading: false,
+          }),
+        },
+      },
+    },
+  },
+}));
+
+vi.mock("next-i18next", () => ({
+  useTranslation: () => ({
+    t: (key: string, options?: Record<string, unknown>) => {
+      if (key === "cancellation_fee_warning_cancel") {
+        const opts = options as {
+          time?: string;
+          unit?: string;
+          amount?: number;
+          formatParams?: { amount?: { currency?: string } };
+        };
+        return `Cancelling within ${opts?.time} ${opts?.unit} will result in a ${opts?.amount} ${opts?.formatParams?.amount?.currency} cancellation fee being charged to your card.`;
+      }
+      return key;
+    },
+  }),
+}));
+
+vi.mock("@calcom/lib/hooks/useLocale", () => ({
+  useLocale: () => ({
+    t: (key: string, options?: Record<string, unknown>) => {
+      if (key === "cancel_booking_acknowledge_no_show_fee") {
+        const opts = options as {
+          timeValue?: number;
+          timeUnit?: string;
+          amount?: number;
+          formatParams?: { amount?: { currency?: string } };
+        };
+        return `I acknowledge that cancelling within ${opts?.timeValue} ${opts?.timeUnit} will result in a ${opts?.amount} ${opts?.formatParams?.amount?.currency} cancellation fee being charged to my card.`;
+      }
+      return key;
+    },
+  }),
+}));
+
+vi.mock("@calcom/lib/hooks/useTelemetry", () => ({
+  useTelemetry: () => ({
+    event: vi.fn(),
+  }),
+}));
+
+vi.mock("@calcom/lib/hooks/useRefreshData", () => ({
+  useRefreshData: () => vi.fn(),
+}));
+
+vi.mock("next/router", () => ({
+  useRouter: () => ({
+    push: vi.fn(),
+    query: {},
+  }),
+}));
+
+vi.mock("@calcom/lib/payment/shouldChargeNoShowCancellationFee", () => ({
+  shouldChargeNoShowCancellationFee: vi.fn(),
+}));
+
+const mockBookingWithCancellationFee = {
+  uid: "test-booking-uid",
+  title: "Test Meeting",
+  id: 123,
+  startTime: new Date(Date.now() + 30 * 60 * 1000),
+  payment: {
+    amount: 1000,
+    currency: "usd",
+    appId: "stripe",
+  },
+};
+
+const mockEventTypeMetadataWithFee = {
+  apps: {
+    stripe: {
+      autoChargeNoShowFeeIfCancelled: true,
+      autoChargeNoShowFeeTimeValue: 1,
+      autoChargeNoShowFeeTimeUnit: "hours" as const,
+      paymentOption: "HOLD" as const,
+    },
+  },
+};
+
+const mockEventTypeMetadataWithoutFee = {
+  apps: {
+    stripe: {
+      autoChargeNoShowFeeIfCancelled: true,
+      autoChargeNoShowFeeTimeValue: 1,
+      autoChargeNoShowFeeTimeUnit: "hours" as const,
+      paymentOption: "HOLD" as const,
+    },
+  },
+};
+
+const mockProps = {
+  recurringEvent: null,
+  setIsCancellationMode: vi.fn(),
+  theme: "light",
+  allRemainingBookings: false,
+  seatReferenceUid: undefined,
+  currentUserEmail: "test@example.com",
+  bookingCancelledEventProps: {
+    booking: {},
+    organizer: {
+      name: "Test Organizer",
+      email: "organizer@example.com",
+      timeZone: "UTC",
+    },
+    eventType: {},
+  },
+  internalNotePresets: [],
+};
+
+const mockBookingWithoutCancellationFee = {
+  uid: "test-booking-uid-2",
+  title: "Test Meeting 2",
+  id: 124,
+  startTime: new Date(Date.now() + 2 * 60 * 60 * 1000),
+  payment: {
+    amount: 1000,
+    currency: "usd",
+    appId: "stripe",
+  },
+};
+
+describe("CancelBooking Cancellation Fee Warning", () => {
+  it("should show cancellation fee warning when booking is within time threshold", () => {
+    vi.mocked(shouldChargeModule.shouldChargeNoShowCancellationFee).mockReturnValue(true);
+
+    render(
+      <CancelBooking
+        booking={mockBookingWithCancellationFee}
+        profile={{ name: "Test User", slug: "test-user" }}
+        team={null}
+        isHost={false}
+        eventTypeMetadata={mockEventTypeMetadataWithFee}
+        {...mockProps}
+      />
+    );
+
+    expect(
+      screen.getByText(/I acknowledge that cancelling within 1 hours will result in a/)
+    ).toBeInTheDocument();
+  });
+
+  it("should not show cancellation fee warning when booking is outside time threshold", () => {
+    vi.mocked(shouldChargeModule.shouldChargeNoShowCancellationFee).mockReturnValue(false);
+
+    render(
+      <CancelBooking
+        booking={mockBookingWithoutCancellationFee}
+        profile={{ name: "Test User", slug: "test-user" }}
+        team={null}
+        isHost={false}
+        eventTypeMetadata={mockEventTypeMetadataWithoutFee}
+        {...mockProps}
+      />
+    );
+
+    expect(screen.queryByText(/I acknowledge that cancelling within/)).not.toBeInTheDocument();
+  });
+
+  it("should not show cancellation fee warning when user is host", () => {
+    vi.mocked(shouldChargeModule.shouldChargeNoShowCancellationFee).mockReturnValue(false);
+
+    render(
+      <CancelBooking
+        booking={mockBookingWithCancellationFee}
+        profile={{ name: "Test User", slug: "test-user" }}
+        team={null}
+        isHost={true}
+        eventTypeMetadata={mockEventTypeMetadataWithFee}
+        {...mockProps}
+      />
+    );
+
+    expect(screen.queryByText(/I acknowledge that cancelling within/)).not.toBeInTheDocument();
+  });
+
+  it("should not show cancellation fee warning when cancellation fee is disabled", () => {
+    const eventTypeMetadataWithDisabledFee = {
+      apps: {
+        stripe: {
+          autoChargeNoShowFeeIfCancelled: false,
+          autoChargeNoShowFeeTimeValue: 1,
+          autoChargeNoShowFeeTimeUnit: "hours" as const,
+          paymentOption: "HOLD" as const,
+        },
+      },
+    };
+
+    vi.mocked(shouldChargeModule.shouldChargeNoShowCancellationFee).mockReturnValue(false);
+
+    render(
+      <CancelBooking
+        booking={mockBookingWithCancellationFee}
+        profile={{ name: "Test User", slug: "test-user" }}
+        team={null}
+        isHost={false}
+        eventTypeMetadata={eventTypeMetadataWithDisabledFee}
+        {...mockProps}
+      />
+    );
+
+    expect(screen.queryByText(/I acknowledge that cancelling within/)).not.toBeInTheDocument();
+  });
+
+  it("should not show cancellation fee warning when payment option is not HOLD", () => {
+    const eventTypeMetadataWithOnBookingPayment = {
+      apps: {
+        stripe: {
+          autoChargeNoShowFeeIfCancelled: true,
+          autoChargeNoShowFeeTimeValue: 1,
+          autoChargeNoShowFeeTimeUnit: "hours" as const,
+          paymentOption: "ON_BOOKING" as const,
+        },
+      },
+    };
+
+    vi.mocked(shouldChargeModule.shouldChargeNoShowCancellationFee).mockReturnValue(false);
+
+    render(
+      <CancelBooking
+        booking={mockBookingWithCancellationFee}
+        profile={{ name: "Test User", slug: "test-user" }}
+        team={null}
+        isHost={false}
+        eventTypeMetadata={eventTypeMetadataWithOnBookingPayment}
+        {...mockProps}
+      />
+    );
+
+    expect(screen.queryByText(/I acknowledge that cancelling within/)).not.toBeInTheDocument();
+  });
+});
diff --git a/apps/web/modules/bookings/views/bookings-single-view.getServerSideProps.tsx b/apps/web/modules/bookings/views/bookings-single-view.getServerSideProps.tsx
index 19f30fe8cdd743..505d59f8b64a3f 100644
--- a/apps/web/modules/bookings/views/bookings-single-view.getServerSideProps.tsx
+++ b/apps/web/modules/bookings/views/bookings-single-view.getServerSideProps.tsx
@@ -184,6 +184,7 @@ export async function getServerSideProps(context: GetServerSidePropsContext) {
       bookingId: bookingInfo.id,
     },
     select: {
+      appId: true,
       success: true,
       refunded: true,
       currency: true,
diff --git a/apps/web/modules/bookings/views/bookings-single-view.tsx b/apps/web/modules/bookings/views/bookings-single-view.tsx
index 573a786c16d75e..d1d8a9dc6d1f86 100644
--- a/apps/web/modules/bookings/views/bookings-single-view.tsx
+++ b/apps/web/modules/bookings/views/bookings-single-view.tsx
@@ -867,7 +867,10 @@ export default function Success(props: PageProps) {
                               uid: bookingInfo?.uid,
                               title: bookingInfo?.title,
                               id: bookingInfo?.id,
+                              startTime: bookingInfo?.startTime,
+                              payment: props.paymentStatus,
                             }}
+                            eventTypeMetadata={eventType.metadata}
                             profile={{ name: props.profile.name, slug: props.profile.slug }}
                             recurringEvent={eventType.recurringEvent}
                             team={eventType?.team?.name}
diff --git a/apps/web/playwright/cancellation-fee-warning.e2e.ts b/apps/web/playwright/cancellation-fee-warning.e2e.ts
new file mode 100644
index 00000000000000..93f966c7e01deb
--- /dev/null
+++ b/apps/web/playwright/cancellation-fee-warning.e2e.ts
@@ -0,0 +1,94 @@
+import { expect } from "@playwright/test";
+import type Prisma from "@prisma/client";
+
+import { test } from "./lib/fixtures";
+import { IS_STRIPE_ENABLED, selectFirstAvailableTimeSlotNextMonth } from "./lib/testUtils";
+
+test.describe.configure({ mode: "parallel" });
+test.afterEach(({ users }) => users.deleteAll());
+
+test.describe("Cancellation Fee Warning E2E", () => {
+  test("Should display cancellation fee warning during booking submission", async ({ page, users }) => {
+    // eslint-disable-next-line playwright/no-skipped-test
+    test.skip(!IS_STRIPE_ENABLED, "It should only run if Stripe is installed");
+    const user = await users.create();
+    const eventType = user.eventTypes.find((e) => e.slug === "paid") as Prisma.EventType;
+    await user.apiLogin();
+    await page.goto("/apps/installed");
+
+    await user.installStripePersonal({ skip: true });
+    await user.setupEventWithPrice(eventType, "stripe");
+
+    await page.goto(`/event-types/${eventType?.id}?tabName=advanced`);
+
+    await page.locator('[data-testid="cancellation-fee-toggle"]').click();
+    await page.locator('[data-testid="cancellation-fee-time-value"]').fill("2");
+    await page.locator('[data-testid="cancellation-fee-time-unit"]').selectOption("hours");
+
+    await page.getByTestId("update-eventtype").click();
+
+    await page.goto(`${user.username}/${eventType?.slug}`);
+    await selectFirstAvailableTimeSlotNextMonth(page);
+
+    await page.fill('[name="name"]', "Test Booker");
+    await page.fill('[name="email"]', "booker@example.com");
+
+    await expect(page.getByText(/I acknowledge that if I cancel within 2 hours/)).toBeVisible();
+  });
+
+  test("Should display cancellation fee warning during cancellation", async ({ page, users }) => {
+    // eslint-disable-next-line playwright/no-skipped-test
+    test.skip(!IS_STRIPE_ENABLED, "It should only run if Stripe is installed");
+    const user = await users.create();
+    const eventType = user.eventTypes.find((e) => e.slug === "paid") as Prisma.EventType;
+    await user.apiLogin();
+    await page.goto("/apps/installed");
+
+    await user.installStripePersonal({ skip: true });
+    await user.setupEventWithPrice(eventType, "stripe");
+
+    await page.goto(`/event-types/${eventType?.id}?tabName=advanced`);
+
+    await page.locator('[data-testid="cancellation-fee-toggle"]').click();
+    await page.locator('[data-testid="cancellation-fee-time-value"]').fill("24");
+    await page.locator('[data-testid="cancellation-fee-time-unit"]').selectOption("hours");
+
+    await page.getByTestId("update-eventtype").click();
+
+    await user.bookAndPayEvent(eventType);
+    await expect(page.locator("[data-testid=success-page]")).toBeVisible();
+
+    await page.goto("/bookings/upcoming");
+    await page.click('[data-testid="cancel"]');
+
+    await expect(page.getByText(/Cancelling within 24 hours will result in a/)).toBeVisible();
+  });
+
+  test("Should not display cancellation fee warning when outside time threshold", async ({ page, users }) => {
+    // eslint-disable-next-line playwright/no-skipped-test
+    test.skip(!IS_STRIPE_ENABLED, "It should only run if Stripe is installed");
+    const user = await users.create();
+    const eventType = user.eventTypes.find((e) => e.slug === "paid") as Prisma.EventType;
+    await user.apiLogin();
+    await page.goto("/apps/installed");
+
+    await user.installStripePersonal({ skip: true });
+    await user.setupEventWithPrice(eventType, "stripe");
+
+    await page.goto(`/event-types/${eventType?.id}?tabName=advanced`);
+
+    await page.locator('[data-testid="cancellation-fee-toggle"]').click();
+    await page.locator('[data-testid="cancellation-fee-time-value"]').fill("1");
+    await page.locator('[data-testid="cancellation-fee-time-unit"]').selectOption("minutes");
+
+    await page.getByTestId("update-eventtype").click();
+
+    await page.goto(`${user.username}/${eventType?.slug}`);
+    await selectFirstAvailableTimeSlotNextMonth(page);
+
+    await page.fill('[name="name"]', "Test Booker");
+    await page.fill('[name="email"]', "booker@example.com");
+
+    await expect(page.getByText(/I acknowledge that if I cancel within/)).toBeHidden();
+  });
+});
diff --git a/apps/web/public/static/locales/en/common.json b/apps/web/public/static/locales/en/common.json
index b2bc8855fe3b0c..33093154628799 100644
--- a/apps/web/public/static/locales/en/common.json
+++ b/apps/web/public/static/locales/en/common.json
@@ -2311,6 +2311,7 @@
   "testing_workflow_info_message": "When testing this workflow, be aware that Emails and SMS can only be scheduled at least 1 hour in advance",
   "insights_no_data_found_for_filter": "No data found for the selected filter or selected dates.",
   "acknowledge_booking_no_show_fee": "I acknowledge that if I do not attend this event that a {{amount, currency}} no show fee will be applied to my card.",
+  "days": "days",
   "card_details": "Card details",
   "something_went_wrong_on_our_end": "Something went wrong on our end. Get in touch with our support team, and we'll get it fixed right away for you.",
   "please_provide_following_text_to_suppport": "Please provide the following text when contacting support to better help you",
@@ -3602,5 +3603,9 @@
   "search_variables": "Search variables",
   "no_variables_found": "No variables found",
   "api_key_name_too_long": "Name must not exceed {{max}} characters",
+  "auto_charge_for_last_minute_cancellation": "Auto charge no-show fee for last minute cancellations",
+  "before_scheduled_start_time": "Before scheduled start time",
+  "cancel_booking_acknowledge_no_show_fee": "I acknowledge that by cancelling the booking within {{timeValue}} {{timeUnit}} of the start time I will be charged the no show fee of {{amount, currency}}",
+  "contact_organizer": "If you have any questions, please contact the organizer.",
   "ADD_NEW_STRINGS_ABOVE_THIS_LINE_TO_PREVENT_MERGE_CONFLICTS": "↑↑↑↑↑↑↑↑↑↑↑↑↑ Add your new strings above here ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"
 }
diff --git a/packages/app-store/stripepayment/components/EventTypeAppSettingsInterface.tsx b/packages/app-store/stripepayment/components/EventTypeAppSettingsInterface.tsx
index fa2ac657fa05d5..7d320576afb347 100644
--- a/packages/app-store/stripepayment/components/EventTypeAppSettingsInterface.tsx
+++ b/packages/app-store/stripepayment/components/EventTypeAppSettingsInterface.tsx
@@ -7,6 +7,7 @@ import { RefundPolicy } from "@calcom/lib/payment/types";
 import classNames from "@calcom/ui/classNames";
 import { Alert } from "@calcom/ui/components/alert";
 import { Select } from "@calcom/ui/components/form";
+import { CheckboxField } from "@calcom/ui/components/form";
 import { TextField } from "@calcom/ui/components/form";
 import { RadioField } from "@calcom/ui/components/radio";
 
@@ -16,6 +17,7 @@ import {
 } from "../../_utils/payments/currencyConversions";
 import { paymentOptions } from "../lib/constants";
 import { currencyOptions } from "../lib/currencyOptions";
+import { autoChargeNoShowFeeTimeUnitEnum } from "../zod";
 
 type Option = { value: string; label: string };
 
@@ -38,6 +40,9 @@ const EventTypeAppSettingsInterface: EventTypeAppSettingsComponent = ({
   const requirePayment = getAppData("enabled");
   const getSelectedOption = () =>
     options.find((opt) => opt.value === (getAppData("refundCountCalendarDays") === true ? 1 : 0));
+  const autoChargeNoShowFeeIfCancelled = getAppData("autoChargeNoShowFeeIfCancelled");
+  const autoChargeNoShowFeeTimeUnit = getAppData("autoChargeNoShowFeeTimeUnit");
+  const autoChargeNoShowFeeTimeValue = getAppData("autoChargeNoShowFeeTimeValue");
 
   const { t } = useLocale();
   const recurringEventDefined = eventType.recurringEvent?.count !== undefined;
@@ -72,6 +77,11 @@ const EventTypeAppSettingsInterface: EventTypeAppSettingsComponent = ({
     { value: 0, label: t("business_days") },
     { value: 1, label: t("calendar_days") },
   ];
+  const autoChangeTimeUnitOptions = [
+    { value: autoChargeNoShowFeeTimeUnitEnum.enum.minutes, label: t("minutes") },
+    { value: autoChargeNoShowFeeTimeUnitEnum.enum.hours, label: t("hours") },
+    { value: autoChargeNoShowFeeTimeUnitEnum.enum.days, label: t("days") },
+  ];
   return (
     <>
       {recurringEventDefined && (
@@ -151,11 +161,9 @@ const EventTypeAppSettingsInterface: EventTypeAppSettingsComponent = ({
               isDisabled={seatsEnabled || disabled}
             />
           </div>
-
           {seatsEnabled && paymentOption === "HOLD" && (
             <Alert className="mt-2" severity="warning" title={t("seats_and_no_show_fee_error")} />
           )}
-
           {paymentOption !== "HOLD" && (
             <div className="mt-4 w-full">
               <label className="text-default mb-1 block text-sm font-medium">{t("refund_policy")}</label>
@@ -210,6 +218,54 @@ const EventTypeAppSettingsInterface: EventTypeAppSettingsComponent = ({
               </RadioGroup.Root>
             </div>
           )}
+          {paymentOption === "HOLD" && (
+            <div className="mt-4">
+              <div>
+                <CheckboxField
+                  checked={autoChargeNoShowFeeIfCancelled}
+                  onChange={(e) => setAppData("autoChargeNoShowFeeIfCancelled", e.target.checked)}
+                  description={t("auto_charge_for_last_minute_cancellation")}
+                />
+              </div>
+              {autoChargeNoShowFeeIfCancelled && (
+                <div>
+                  <div className="mt-2 flex items-center">
+                    <TextField
+                      labelSrOnly
+                      type="number"
+                      className={classNames(
+                        "border-default my-0 block w-16 text-sm [appearance:textfield] ltr:mr-2 rtl:ml-2"
+                      )}
+                      placeholder="2"
+                      disabled={disabled}
+                      min={0}
+                      defaultValue={autoChargeNoShowFeeTimeValue}
+                      required={autoChargeNoShowFeeIfCancelled}
+                      value={autoChargeNoShowFeeTimeValue ?? ""}
+                      onChange={(e) =>
+                        setAppData("autoChargeNoShowFeeTimeValue", parseInt(e.currentTarget.value))
+                      }
+                    />
+                    <Select
+                      options={autoChangeTimeUnitOptions}
+                      isSearchable={false}
+                      isDisabled={disabled}
+                      onChange={(option) => setAppData("autoChargeNoShowFeeTimeUnit", option?.value)}
+                      value={
+                        autoChangeTimeUnitOptions.find((opt) => opt.value === autoChargeNoShowFeeTimeUnit) ||
+                        autoChangeTimeUnitOptions[0]
+                      }
+                      defaultValue={
+                        autoChangeTimeUnitOptions.find((opt) => opt.value === autoChargeNoShowFeeTimeUnit) ||
+                        autoChangeTimeUnitOptions[0]
+                      }
+                    />
+                    <span className="me-2 ms-2">{t("before_scheduled_start_time")}</span>
+                  </div>
+                </div>
+              )}
+            </div>
+          )}
         </>
       )}
     </>
diff --git a/packages/app-store/stripepayment/zod.ts b/packages/app-store/stripepayment/zod.ts
index 4817fa09337845..8b56e982c2374c 100644
--- a/packages/app-store/stripepayment/zod.ts
+++ b/packages/app-store/stripepayment/zod.ts
@@ -14,6 +14,8 @@ const VALUES: [PaymentOption, ...PaymentOption[]] = [
 ];
 export const paymentOptionEnum = z.enum(VALUES);
 
+export const autoChargeNoShowFeeTimeUnitEnum = z.enum(["minutes", "hours", "days"]);
+
 export const appDataSchema = eventTypeAppCardZod.merge(
   z.object({
     price: z.number(),
@@ -23,6 +25,9 @@ export const appDataSchema = eventTypeAppCardZod.merge(
     refundPolicy: z.nativeEnum(RefundPolicy).optional(),
     refundDaysCount: z.number().optional(),
     refundCountCalendarDays: z.boolean().optional(),
+    autoChargeNoShowFeeIfCancelled: z.boolean().optional(),
+    autoChargeNoShowFeeTimeValue: z.number().optional(),
+    autoChargeNoShowFeeTimeUnit: autoChargeNoShowFeeTimeUnitEnum.optional(),
   })
 );
 
diff --git a/packages/features/bookings/lib/getBookingToDelete.ts b/packages/features/bookings/lib/getBookingToDelete.ts
index e218ec254acc75..7310589c515d04 100644
--- a/packages/features/bookings/lib/getBookingToDelete.ts
+++ b/packages/features/bookings/lib/getBookingToDelete.ts
@@ -22,6 +22,7 @@ export async function getBookingToDelete(id: number | undefined, uid: string | u
           timeFormat: true,
           name: true,
           destinationCalendar: true,
+          locale: true,
         },
       },
       location: true,
@@ -46,6 +47,7 @@ export async function getBookingToDelete(id: number | undefined, uid: string | u
               hideBranding: true,
             },
           },
+          teamId: true,
           team: {
             select: {
               id: true,
diff --git a/packages/features/bookings/lib/handleCancelBooking.ts b/packages/features/bookings/lib/handleCancelBooking.ts
index 2c0b11710fd657..7aae05fd49658f 100644
--- a/packages/features/bookings/lib/handleCancelBooking.ts
+++ b/packages/features/bookings/lib/handleCancelBooking.ts
@@ -23,6 +23,7 @@ import { HttpError } from "@calcom/lib/http-error";
 import { isPrismaObjOrUndefined } from "@calcom/lib/isPrismaObj";
 import { parseRecurringEvent } from "@calcom/lib/isRecurringEvent";
 import logger from "@calcom/lib/logger";
+import { processNoShowFeeOnCancellation } from "@calcom/lib/payment/processNoShowFeeOnCancellation";
 import { processPaymentRefund } from "@calcom/lib/payment/processPaymentRefund";
 import { safeStringify } from "@calcom/lib/safeStringify";
 import { getTranslation } from "@calcom/lib/server/i18n";
@@ -194,7 +195,6 @@ async function handler(input: CancelBookingInput) {
 
   const teamMembersPromises = [];
   const attendeesListPromises = [];
-  const hostsPresent = !!bookingToDelete.eventType?.hosts;
   const hostEmails = new Set(bookingToDelete.eventType?.hosts?.map((host) => host.user.email) ?? []);
 
   for (let index = 0; index < bookingToDelete.attendees.length; index++) {
@@ -455,11 +455,17 @@ async function handler(input: CancelBookingInput) {
     });
     updatedBookings.push(updatedBooking);
 
-    if (!!bookingToDelete.payment.length) {
+    if (bookingToDelete.payment.some((payment) => payment.paymentOption === "ON_BOOKING")) {
       await processPaymentRefund({
         booking: bookingToDelete,
         teamId,
       });
+    } else if (bookingToDelete.payment.some((payment) => payment.paymentOption === "HOLD")) {
+      await processNoShowFeeOnCancellation({
+        booking: bookingToDelete,
+        payments: bookingToDelete.payment,
+        cancelledByUserId: userId,
+      });
     }
   }
 
diff --git a/packages/features/bookings/lib/handleCancelBooking/test/handleCancelBooking.test.ts b/packages/features/bookings/lib/handleCancelBooking/test/handleCancelBooking.test.ts
index fdd7eec07b4f41..b8fd0870574756 100644
--- a/packages/features/bookings/lib/handleCancelBooking/test/handleCancelBooking.test.ts
+++ b/packages/features/bookings/lib/handleCancelBooking/test/handleCancelBooking.test.ts
@@ -509,4 +509,365 @@ describe("Cancel Booking", () => {
       })
     ).rejects.toThrow("Cannot cancel a booking that has already ended");
   });
+
+  test("Should not charge cancellation fee when organizer cancels booking", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 101,
+      schedules: [TestData.schedules.IstWorkHours],
+      credentials: [getGoogleCalendarCredential()],
+      selectedCalendars: [TestData.selectedCalendars.google],
+    });
+
+    const uidOfBookingToBeCancelled = "cancellation-fee-organizer-test";
+    const idOfBookingToBeCancelled = 4050;
+    const { dateString: plus1DateString } = getDate({ dateIncrement: 1 });
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 1,
+            slotInterval: 30,
+            length: 30,
+            users: [{ id: 101 }],
+            metadata: {
+              apps: {
+                stripe: {
+                  enabled: true,
+                  paymentOption: "HOLD",
+                  price: 1000,
+                  currency: "usd",
+                  cancellationFeeEnabled: true,
+                  cancellationFeeTimeValue: 2,
+                  cancellationFeeTimeUnit: "hours",
+                },
+              },
+            },
+          },
+        ],
+        bookings: [
+          {
+            id: idOfBookingToBeCancelled,
+            uid: uidOfBookingToBeCancelled,
+            eventTypeId: 1,
+            userId: 101,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+              location: { optionValue: "", value: BookingLocations.CalVideo },
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: `${plus1DateString}T05:00:00.000Z`,
+            endTime: `${plus1DateString}T05:30:00.000Z`,
+            attendees: [
+              {
+                email: booker.email,
+                timeZone: "Asia/Kolkata",
+              },
+            ],
+          },
+        ],
+        payment: [
+          {
+            amount: 1000,
+            bookingId: idOfBookingToBeCancelled,
+            currency: "usd",
+            data: {},
+            externalId: "ext_id_cancellation",
+            fee: 0,
+            refunded: false,
+            success: false,
+            uid: uidOfBookingToBeCancelled,
+            paymentOption: "HOLD",
+          },
+        ],
+        organizer,
+        apps: [TestData.apps["daily-video"]],
+      })
+    );
+
+    mockSuccessfulVideoMeetingCreation({
+      metadataLookupKey: "dailyvideo",
+      videoMeetingData: {
+        id: "MOCK_ID",
+        password: "MOCK_PASS",
+        url: `http://mock-dailyvideo.example.com/meeting-cancellation`,
+      },
+    });
+
+    mockCalendarToHaveNoBusySlots("googlecalendar", {
+      create: {
+        id: "MOCKED_GOOGLE_CALENDAR_EVENT_ID_CANCELLATION",
+      },
+    });
+
+    const result = await handleCancelBooking({
+      bookingData: {
+        id: idOfBookingToBeCancelled,
+        uid: uidOfBookingToBeCancelled,
+        cancelledBy: organizer.email,
+      },
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  test("Should not charge cancellation fee when team admin cancels booking", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+    });
+
+    const organizer = getOrganizer({
+      name: "Team Admin",
+      email: "admin@example.com",
+      id: 101,
+      schedules: [TestData.schedules.IstWorkHours],
+      credentials: [getGoogleCalendarCredential()],
+      selectedCalendars: [TestData.selectedCalendars.google],
+    });
+
+    const teamMember = getOrganizer({
+      name: "Team Member",
+      email: "member@example.com",
+      id: 102,
+      schedules: [TestData.schedules.IstWorkHours],
+      credentials: [getGoogleCalendarCredential()],
+      selectedCalendars: [TestData.selectedCalendars.google],
+    });
+
+    const uidOfBookingToBeCancelled = "cancellation-fee-team-admin-test";
+    const idOfBookingToBeCancelled = 4060;
+    const { dateString: plus1DateString } = getDate({ dateIncrement: 1 });
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 2,
+            slotInterval: 30,
+            length: 30,
+            teamId: 1,
+            users: [{ id: 101 }, { id: 102 }],
+            hosts: [
+              { userId: 101, isFixed: false },
+              { userId: 102, isFixed: false },
+            ],
+            metadata: {
+              apps: {
+                stripe: {
+                  enabled: true,
+                  paymentOption: "HOLD",
+                  price: 1000,
+                  currency: "usd",
+                  cancellationFeeEnabled: true,
+                  cancellationFeeTimeValue: 1,
+                  cancellationFeeTimeUnit: "hours",
+                },
+              },
+            },
+          },
+        ],
+        bookings: [
+          {
+            id: idOfBookingToBeCancelled,
+            uid: uidOfBookingToBeCancelled,
+            eventTypeId: 2,
+            userId: 102,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+              location: { optionValue: "", value: BookingLocations.CalVideo },
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: `${plus1DateString}T05:00:00.000Z`,
+            endTime: `${plus1DateString}T05:30:00.000Z`,
+            attendees: [
+              {
+                email: booker.email,
+                timeZone: "Asia/Kolkata",
+              },
+            ],
+          },
+        ],
+        payment: [
+          {
+            amount: 1000,
+            bookingId: idOfBookingToBeCancelled,
+            currency: "usd",
+            data: {},
+            externalId: "ext_id_team_cancellation",
+            fee: 0,
+            refunded: false,
+            success: false,
+            uid: uidOfBookingToBeCancelled,
+            paymentOption: "HOLD",
+          },
+        ],
+        teams: [
+          {
+            id: 1,
+            name: "Test Team",
+            slug: "test-team",
+          },
+        ],
+        users: [organizer, teamMember],
+        apps: [TestData.apps["daily-video"]],
+      })
+    );
+
+    mockSuccessfulVideoMeetingCreation({
+      metadataLookupKey: "dailyvideo",
+      videoMeetingData: {
+        id: "MOCK_ID",
+        password: "MOCK_PASS",
+        url: `http://mock-dailyvideo.example.com/meeting-team-cancellation`,
+      },
+    });
+
+    mockCalendarToHaveNoBusySlots("googlecalendar", {
+      create: {
+        id: "MOCKED_GOOGLE_CALENDAR_EVENT_ID_TEAM_CANCELLATION",
+      },
+    });
+
+    const result = await handleCancelBooking({
+      bookingData: {
+        id: idOfBookingToBeCancelled,
+        uid: uidOfBookingToBeCancelled,
+        cancelledBy: organizer.email,
+      },
+    });
+
+    expect(result.success).toBe(true);
+  });
+
+  test("Should charge cancellation fee when attendee cancels within time threshold", async () => {
+    const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking")).default;
+
+    const booker = getBooker({
+      email: "booker@example.com",
+      name: "Booker",
+      id: 999,
+    });
+
+    const organizer = getOrganizer({
+      name: "Organizer",
+      email: "organizer@example.com",
+      id: 101,
+      schedules: [TestData.schedules.IstWorkHours],
+      credentials: [getGoogleCalendarCredential()],
+      selectedCalendars: [TestData.selectedCalendars.google],
+    });
+
+    const uidOfBookingToBeCancelled = "cancellation-fee-attendee-test";
+    const idOfBookingToBeCancelled = 4070;
+
+    const now = new Date();
+    const startTime = new Date(now.getTime() + 30 * 60 * 1000);
+    const endTime = new Date(startTime.getTime() + 30 * 60 * 1000);
+
+    await createBookingScenario(
+      getScenarioData({
+        eventTypes: [
+          {
+            id: 1,
+            slotInterval: 30,
+            length: 30,
+            users: [{ id: 101 }],
+            metadata: {
+              apps: {
+                stripe: {
+                  enabled: true,
+                  paymentOption: "HOLD",
+                  price: 1000,
+                  currency: "usd",
+                  cancellationFeeEnabled: true,
+                  cancellationFeeTimeValue: 1,
+                  cancellationFeeTimeUnit: "hours",
+                },
+              },
+            },
+          },
+        ],
+        bookings: [
+          {
+            id: idOfBookingToBeCancelled,
+            uid: uidOfBookingToBeCancelled,
+            eventTypeId: 1,
+            userId: 101,
+            responses: {
+              email: booker.email,
+              name: booker.name,
+              location: { optionValue: "", value: BookingLocations.CalVideo },
+            },
+            status: BookingStatus.ACCEPTED,
+            startTime: startTime.toISOString(),
+            endTime: endTime.toISOString(),
+            attendees: [
+              {
+                email: booker.email,
+                timeZone: "Asia/Kolkata",
+              },
+            ],
+          },
+        ],
+        payment: [
+          {
+            amount: 1000,
+            bookingId: idOfBookingToBeCancelled,
+            currency: "usd",
+            data: {},
+            externalId: "ext_id_attendee_cancellation",
+            fee: 0,
+            refunded: false,
+            success: false,
+            uid: uidOfBookingToBeCancelled,
+            paymentOption: "HOLD",
+            appId: "stripe",
+          },
+        ],
+        organizer,
+        apps: [TestData.apps["daily-video"]],
+      })
+    );
+
+    mockSuccessfulVideoMeetingCreation({
+      metadataLookupKey: "dailyvideo",
+      videoMeetingData: {
+        id: "MOCK_ID",
+        password: "MOCK_PASS",
+        url: `http://mock-dailyvideo.example.com/meeting-attendee-cancellation`,
+      },
+    });
+
+    mockCalendarToHaveNoBusySlots("googlecalendar", {
+      create: {
+        id: "MOCKED_GOOGLE_CALENDAR_EVENT_ID_ATTENDEE_CANCELLATION",
+      },
+    });
+
+    const result = await handleCancelBooking({
+      bookingData: {
+        id: idOfBookingToBeCancelled,
+        uid: uidOfBookingToBeCancelled,
+        cancelledBy: booker.email,
+        cancellationReason: "Attendee cancelled within time threshold",
+      },
+      userId: 999,
+    });
+
+    expect(result.success).toBe(true);
+  });
 });
diff --git a/packages/lib/payment/handleNoShowFee.ts b/packages/lib/payment/handleNoShowFee.ts
new file mode 100644
index 00000000000000..df55f679ee5102
--- /dev/null
+++ b/packages/lib/payment/handleNoShowFee.ts
@@ -0,0 +1,179 @@
+import type { Prisma } from "@prisma/client";
+
+// eslint-disable-next-line
+import { PaymentServiceMap } from "@calcom/app-store/payment.services.generated";
+import dayjs from "@calcom/dayjs";
+import { sendNoShowFeeChargedEmail } from "@calcom/emails";
+import { ErrorCode } from "@calcom/lib/errorCodes";
+import { ErrorWithCode } from "@calcom/lib/errors";
+import logger from "@calcom/lib/logger";
+import { getTranslation } from "@calcom/lib/server/i18n";
+import { CredentialRepository } from "@calcom/lib/server/repository/credential";
+import { MembershipRepository } from "@calcom/lib/server/repository/membership";
+import { TeamRepository } from "@calcom/lib/server/repository/team";
+import prisma from "@calcom/prisma";
+import { eventTypeMetaDataSchemaWithTypedApps } from "@calcom/prisma/zod-utils";
+import type { CalendarEvent } from "@calcom/types/Calendar";
+import type { IAbstractPaymentService } from "@calcom/types/PaymentService";
+
+export const handleNoShowFee = async ({
+  booking,
+  payment,
+}: {
+  booking: {
+    id: number;
+    uid: string;
+    title: string;
+    startTime: Date;
+    endTime: Date;
+    userPrimaryEmail: string | null;
+    userId: number | null;
+    user?: {
+      email: string;
+      name?: string | null;
+      locale: string | null;
+      timeZone: string;
+    } | null;
+    eventType: {
+      title: string;
+      hideOrganizerEmail: boolean;
+      teamId: number | null;
+      metadata?: Prisma.JsonValue;
+    } | null;
+    attendees: {
+      name: string;
+      email: string;
+      timeZone: string;
+      locale: string | null;
+    }[];
+  };
+  payment: {
+    id: number;
+    amount: number;
+    currency: string;
+    paymentOption: string | null;
+    appId: string | null;
+  };
+}) => {
+  const log = logger.getSubLogger({ prefix: [`[handleNoShowFee] bookingUid ${booking.uid}`] });
+  const tOrganizer = await getTranslation(booking.user?.locale ?? "en", "common");
+
+  const userId = booking.userId;
+  const teamId = booking.eventType?.teamId;
+  const appId = payment.appId;
+
+  const eventTypeMetdata = eventTypeMetaDataSchemaWithTypedApps.parse(booking.eventType?.metadata ?? {});
+
+  if (!userId) {
+    log.error("User ID is required");
+    throw new Error("User ID is required");
+  }
+
+  const attendeesListPromises = [];
+
+  for (const attendee of booking.attendees) {
+    const attendeeObject = {
+      name: attendee.name,
+      email: attendee.email,
+      timeZone: attendee.timeZone,
+      language: {
+        translate: await getTranslation(attendee.locale ?? "en", "common"),
+        locale: attendee.locale ?? "en",
+      },
+    };
+
+    attendeesListPromises.push(attendeeObject);
+  }
+
+  const attendeesList = await Promise.all(attendeesListPromises);
+
+  const evt: CalendarEvent = {
+    type: (booking?.eventType?.title as string) || booking?.title,
+    title: booking.title,
+    startTime: dayjs(booking.startTime).format(),
+    endTime: dayjs(booking.endTime).format(),
+    organizer: {
+      email: booking?.userPrimaryEmail ?? booking.user?.email ?? "",
+      name: booking.user?.name || "Nameless",
+      timeZone: booking.user?.timeZone || "",
+      language: { translate: tOrganizer, locale: booking.user?.locale ?? "en" },
+    },
+    attendees: attendeesList,
+    hideOrganizerEmail: booking.eventType?.hideOrganizerEmail,
+    paymentInfo: {
+      amount: payment.amount,
+      currency: payment.currency,
+      paymentOption: payment.paymentOption,
+    },
+  };
+
+  if (teamId) {
+    const userIsInTeam = await MembershipRepository.findUniqueByUserIdAndTeamId({
+      userId,
+      teamId,
+    });
+
+    if (!userIsInTeam) {
+      log.error(`User ${userId} is not a member of team ${teamId}`);
+      throw new Error("User is not a member of the team");
+    }
+  }
+  let paymentCredential = await CredentialRepository.findPaymentCredentialByAppIdAndUserIdOrTeamId({
+    appId,
+    userId,
+    teamId,
+  });
+
+  if (!paymentCredential && teamId) {
+    const teamRepository = new TeamRepository(prisma);
+    // See if the team event belongs to an org
+    const org = await teamRepository.findParentOrganizationByTeamId(teamId);
+
+    if (org) {
+      paymentCredential = await CredentialRepository.findPaymentCredentialByAppIdAndTeamId({
+        appId,
+        teamId: org.id,
+      });
+    }
+  }
+
+  if (!paymentCredential) {
+    log.error(`No payment credential found for user ${userId} or team ${teamId}`);
+    throw new Error("No payment credential found");
+  }
+
+  const key = paymentCredential?.app?.dirName;
+  const paymentAppImportFn = PaymentServiceMap[key as keyof typeof PaymentServiceMap];
+  if (!paymentAppImportFn) {
+    log.error(`Payment app ${key} not implemented`);
+    throw new Error("Payment app not implemented");
+  }
+  const paymentApp = await paymentAppImportFn;
+  if (!paymentApp?.PaymentService) {
+    log.error(`Payment service not found for app ${key}`);
+    throw new Error("Payment service not found");
+  }
+  const PaymentService = paymentApp.PaymentService;
+  const paymentInstance = new PaymentService(paymentCredential) as IAbstractPaymentService;
+
+  try {
+    const paymentData = await paymentInstance.chargeCard(payment, booking.id);
+
+    if (!paymentData) {
+      log.error(`Error processing payment with paymentId ${payment.id}`);
+      throw new Error("Payment processing failed");
+    }
+
+    await sendNoShowFeeChargedEmail(attendeesListPromises[0], evt, eventTypeMetdata);
+
+    return paymentData;
+  } catch (err) {
+    let errorMessage = `Error processing paymentId ${payment.id} with error ${err}`;
+    if (err instanceof ErrorWithCode && err.code === ErrorCode.ChargeCardFailure) {
+      errorMessage = err.message;
+    }
+
+    log.error(errorMessage);
+    throw new Error(tOrganizer(errorMessage));
+  }
+};
diff --git a/packages/lib/payment/processNoShowFeeOnCancellation.ts b/packages/lib/payment/processNoShowFeeOnCancellation.ts
new file mode 100644
index 00000000000000..dd57c4bfd149cb
--- /dev/null
+++ b/packages/lib/payment/processNoShowFeeOnCancellation.ts
@@ -0,0 +1,77 @@
+import logger from "@calcom/lib/logger";
+import { MembershipRepository } from "@calcom/lib/server/repository/membership";
+import type { Payment } from "@calcom/prisma/client";
+import { eventTypeMetaDataSchemaWithTypedApps } from "@calcom/prisma/zod-utils";
+
+import { handleNoShowFee } from "./handleNoShowFee";
+import { shouldChargeNoShowCancellationFee } from "./shouldChargeNoShowCancellationFee";
+
+export const processNoShowFeeOnCancellation = async ({
+  booking,
+  payments,
+  cancelledByUserId,
+}: {
+  booking: Parameters<typeof handleNoShowFee>[0]["booking"];
+  payments: Payment[];
+  cancelledByUserId?: number;
+}) => {
+  const log = logger.getSubLogger({ prefix: ["processNoShowFeeOnCancellation"] });
+
+  // Skip no-show fee if the booking was cancelled by the organizer or team/org admin
+  if (cancelledByUserId && booking.userId === cancelledByUserId) {
+    log.info(
+      `Booking ${booking.uid} was cancelled by the organizer (${cancelledByUserId}), skipping no-show fee`
+    );
+    return;
+  }
+
+  // Skip no-show fee if the booking was cancelled by a team/org admin
+  if (cancelledByUserId && booking.eventType?.teamId) {
+    const membership = await MembershipRepository.findUniqueByUserIdAndTeamId({
+      userId: cancelledByUserId,
+      teamId: booking.eventType.teamId,
+    });
+
+    if (membership && (membership.role === "ADMIN" || membership.role === "OWNER")) {
+      log.info(
+        `Booking ${booking.uid} was cancelled by team admin/owner (${cancelledByUserId}), skipping no-show fee`
+      );
+      return;
+    }
+  }
+
+  const paymentToCharge = payments.find(
+    (payment) => payment.paymentOption === "HOLD" && payment.success === false
+  );
+
+  if (!paymentToCharge) {
+    log.info(`No payment found to charge for booking ${booking.uid}`);
+    return;
+  }
+
+  // Parse the event type metadata
+  const eventTypeMetadata = eventTypeMetaDataSchemaWithTypedApps.parse(booking.eventType?.metadata ?? {});
+
+  // Determine if we need to charge the no-show fee
+  const shouldChargeNoShowFee = shouldChargeNoShowCancellationFee({
+    booking,
+    eventTypeMetadata,
+    payment: paymentToCharge,
+  });
+
+  if (!shouldChargeNoShowFee) {
+    log.info(`Date is not valid for no-show fee to charge for booking ${booking.uid}`);
+    return;
+  }
+
+  // Process charging the no show fee
+  try {
+    await handleNoShowFee({
+      booking,
+      payment: paymentToCharge,
+    });
+  } catch (error) {
+    log.error(`Error charging no-show fee for booking ${booking.uid}`, error);
+    throw new Error(`Failed to charge no-show fee with error ${error}`);
+  }
+};
diff --git a/packages/lib/payment/shouldChargeNoShowCancellationFee.test.ts b/packages/lib/payment/shouldChargeNoShowCancellationFee.test.ts
new file mode 100644
index 00000000000000..126e7fc1df4a8f
--- /dev/null
+++ b/packages/lib/payment/shouldChargeNoShowCancellationFee.test.ts
@@ -0,0 +1,187 @@
+import { describe, expect, it, vi, beforeAll } from "vitest";
+import type { z } from "zod";
+
+import type { eventTypeMetaDataSchemaWithTypedApps } from "@calcom/prisma/zod-utils";
+
+import { shouldChargeNoShowCancellationFee } from "./shouldChargeNoShowCancellationFee";
+
+type EventTypeMetadata = z.infer<typeof eventTypeMetaDataSchemaWithTypedApps>;
+
+beforeAll(() => {
+  vi.setSystemTime(new Date("2024-09-01T10:00:00Z"));
+});
+
+describe("shouldChargeCancellationFee", () => {
+  const mockEventTypeMetadata = {
+    apps: {
+      stripe: {
+        autoChargeNoShowFeeIfCancelled: true,
+        paymentOption: "HOLD",
+        autoChargeNoShowFeeTimeValue: 2,
+        autoChargeNoShowFeeTimeUnit: "hours",
+      },
+    },
+  };
+
+  const mockPayment = {
+    appId: "stripe",
+  };
+
+  it("should return false if cancellation fee is not enabled", () => {
+    const eventTypeMetadata = {
+      apps: {
+        stripe: {
+          autoChargeNoShowFeeIfCancelled: false,
+          paymentOption: "HOLD",
+        },
+      },
+    };
+
+    const result = shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: eventTypeMetadata as EventTypeMetadata,
+      booking: { startTime: new Date("2024-09-01T12:00:00Z") },
+      payment: mockPayment,
+    });
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false if payment option is not HOLD", () => {
+    const eventTypeMetadata = {
+      apps: {
+        stripe: {
+          autoChargeNoShowFeeIfCancelled: true,
+          paymentOption: "ON_BOOKING",
+        },
+      },
+    };
+
+    const result = shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: eventTypeMetadata as EventTypeMetadata,
+      booking: { startTime: new Date("2024-09-01T12:00:00Z") },
+      payment: mockPayment,
+    });
+
+    expect(result).toBe(false);
+  });
+
+  it("should return true if cancelled within time threshold (hours)", () => {
+    const startTime = new Date("2024-09-01T11:30:00Z");
+
+    const result = shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: mockEventTypeMetadata as EventTypeMetadata,
+      booking: { startTime },
+      payment: mockPayment,
+    });
+
+    expect(result).toBe(true);
+  });
+
+  it("should return false if cancelled outside time threshold (hours)", () => {
+    const startTime = new Date("2024-09-01T13:00:00Z");
+
+    const result = shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: mockEventTypeMetadata as EventTypeMetadata,
+      booking: { startTime },
+      payment: mockPayment,
+    });
+
+    expect(result).toBe(false);
+  });
+
+  it("should handle minutes time unit correctly", () => {
+    const mockEventTypeMetadata = {
+      apps: {
+        stripe: {
+          autoChargeNoShowFeeIfCancelled: true,
+          paymentOption: "HOLD",
+          autoChargeNoShowFeeTimeValue: 30,
+          autoChargeNoShowFeeTimeUnit: "minutes",
+        },
+      },
+    };
+
+    const startTime = new Date("2024-09-01T10:15:00Z");
+
+    const result = shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: mockEventTypeMetadata as EventTypeMetadata,
+      booking: { startTime },
+      payment: mockPayment,
+    });
+
+    expect(result).toBe(true);
+  });
+
+  it("should handle days time unit correctly", () => {
+    const mockEventTypeMetadata = {
+      apps: {
+        stripe: {
+          autoChargeNoShowFeeIfCancelled: true,
+          paymentOption: "HOLD",
+          autoChargeNoShowFeeTimeValue: 1,
+          autoChargeNoShowFeeTimeUnit: "days",
+        },
+      },
+    };
+
+    const startTime = new Date("2024-09-02T09:00:00Z");
+
+    const result = shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: mockEventTypeMetadata as EventTypeMetadata,
+      booking: { startTime },
+      payment: mockPayment,
+    });
+
+    expect(result).toBe(true);
+  });
+
+  it("should handle invalid metadata gracefully", () => {
+    const result = shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: null as EventTypeMetadata,
+      booking: { startTime: new Date("2024-09-01T12:00:00Z") },
+      payment: mockPayment,
+    });
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false when timeValue is missing", () => {
+    const mockEventTypeMetadata = {
+      apps: {
+        stripe: {
+          autoChargeNoShowFeeIfCancelled: true,
+          paymentOption: "HOLD",
+          autoChargeNoShowFeeTimeUnit: "days",
+        },
+      },
+    };
+
+    const result = shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: mockEventTypeMetadata as EventTypeMetadata,
+      booking: { startTime: new Date("2024-09-01T12:00:00Z") },
+      payment: mockPayment,
+    });
+
+    expect(result).toBe(false);
+  });
+
+  it("should return false when timeUnit is missing", () => {
+    const mockEventTypeMetadata = {
+      apps: {
+        stripe: {
+          autoChargeNoShowFeeIfCancelled: true,
+          paymentOption: "HOLD",
+          autoChargeNoShowFeeTimeValue: 24,
+        },
+      },
+    };
+
+    const result = shouldChargeNoShowCancellationFee({
+      eventTypeMetadata: mockEventTypeMetadata as EventTypeMetadata,
+      booking: { startTime: new Date("2024-09-01T12:00:00Z") },
+      payment: mockPayment,
+    });
+
+    expect(result).toBe(false);
+  });
+});
diff --git a/packages/lib/payment/shouldChargeNoShowCancellationFee.ts b/packages/lib/payment/shouldChargeNoShowCancellationFee.ts
new file mode 100644
index 00000000000000..ca1bc9ec8a883c
--- /dev/null
+++ b/packages/lib/payment/shouldChargeNoShowCancellationFee.ts
@@ -0,0 +1,58 @@
+import type { z } from "zod";
+
+import type { eventTypeMetaDataSchemaWithTypedApps } from "@calcom/prisma/zod-utils";
+
+export const shouldChargeNoShowCancellationFee = ({
+  eventTypeMetadata,
+  booking,
+  payment,
+}: {
+  eventTypeMetadata: z.infer<typeof eventTypeMetaDataSchemaWithTypedApps>;
+  booking: {
+    startTime: Date;
+  };
+  payment: {
+    appId?: string | null;
+  };
+}) => {
+  const paymentAppId = payment?.appId;
+
+  if (typeof paymentAppId !== "string") {
+    return false;
+  }
+
+  const cancellationFeeEnabled =
+    eventTypeMetadata?.apps?.[paymentAppId as keyof typeof eventTypeMetadata.apps]
+      ?.autoChargeNoShowFeeIfCancelled;
+  const paymentOption =
+    eventTypeMetadata?.apps?.[paymentAppId as keyof typeof eventTypeMetadata.apps]?.paymentOption;
+  const timeValue =
+    eventTypeMetadata?.apps?.[paymentAppId as keyof typeof eventTypeMetadata.apps]
+      ?.autoChargeNoShowFeeTimeValue;
+  const timeUnit =
+    eventTypeMetadata?.apps?.[paymentAppId as keyof typeof eventTypeMetadata.apps]
+      ?.autoChargeNoShowFeeTimeUnit;
+
+  if (!cancellationFeeEnabled || paymentOption !== "HOLD" || !booking?.startTime) {
+    return false;
+  }
+
+  if (!timeValue || !timeUnit) {
+    return false;
+  }
+
+  const multiplier: { [key: string]: number } = {
+    minutes: 1,
+    hours: 60,
+    days: 1440,
+  };
+  const timeInMinutes = timeValue * multiplier[timeUnit];
+
+  const now = new Date();
+  const startTime = new Date(booking.startTime);
+  const threshold = new Date(startTime);
+
+  threshold.setMinutes(threshold.getMinutes() - timeInMinutes);
+
+  return now >= threshold;
+};
diff --git a/packages/lib/server/repository/booking.ts b/packages/lib/server/repository/booking.ts
index 589d00bb4c059f..07fdfe180c9daa 100644
--- a/packages/lib/server/repository/booking.ts
+++ b/packages/lib/server/repository/booking.ts
@@ -945,4 +945,49 @@ export class BookingRepository {
       },
     });
   }
+
+  async getBookingForPaymentProcessing(bookingId: number) {
+    return await this.prismaClient.booking.findUnique({
+      where: {
+        id: bookingId,
+      },
+      select: {
+        id: true,
+        uid: true,
+        title: true,
+        startTime: true,
+        endTime: true,
+        userPrimaryEmail: true,
+        status: true,
+        eventTypeId: true,
+        userId: true,
+        attendees: {
+          select: {
+            name: true,
+            email: true,
+            timeZone: true,
+            locale: true,
+          },
+        },
+        eventType: {
+          select: {
+            title: true,
+            hideOrganizerEmail: true,
+            teamId: true,
+            metadata: true,
+          },
+        },
+        payment: {
+          select: {
+            id: true,
+            amount: true,
+            currency: true,
+            paymentOption: true,
+            appId: true,
+            success: true,
+          },
+        },
+      },
+    });
+  }
 }
diff --git a/packages/trpc/server/routers/viewer/payments/chargeCard.handler.ts b/packages/trpc/server/routers/viewer/payments/chargeCard.handler.ts
index 36582ff8f03e97..2f2bb1d0051c80 100644
--- a/packages/trpc/server/routers/viewer/payments/chargeCard.handler.ts
+++ b/packages/trpc/server/routers/viewer/payments/chargeCard.handler.ts
@@ -1,16 +1,6 @@
-import { PaymentServiceMap } from "@calcom/app-store/payment.services.generated";
-import dayjs from "@calcom/dayjs";
-import { sendNoShowFeeChargedEmail } from "@calcom/emails";
-import { ErrorCode } from "@calcom/lib/errorCodes";
-import { ErrorWithCode } from "@calcom/lib/errors";
-import { getTranslation } from "@calcom/lib/server/i18n";
-import { CredentialRepository } from "@calcom/lib/server/repository/credential";
-import { MembershipRepository } from "@calcom/lib/server/repository/membership";
-import { TeamRepository } from "@calcom/lib/server/repository/team";
+import { handleNoShowFee } from "@calcom/lib/payment/handleNoShowFee";
+import { BookingRepository } from "@calcom/lib/server/repository/booking";
 import type { PrismaClient } from "@calcom/prisma";
-import type { EventTypeMetadata } from "@calcom/prisma/zod-utils";
-import type { CalendarEvent } from "@calcom/types/Calendar";
-import type { IAbstractPaymentService } from "@calcom/types/PaymentService";
 
 import { TRPCError } from "@trpc/server";
 
@@ -23,19 +13,9 @@ interface ChargeCardHandlerOptions {
 }
 export const chargeCardHandler = async ({ ctx, input }: ChargeCardHandlerOptions) => {
   const { prisma } = ctx;
-  const teamRepository = new TeamRepository(prisma);
+  const bookingRepository = new BookingRepository(prisma);
 
-  const booking = await prisma.booking.findUnique({
-    where: {
-      id: input.bookingId,
-    },
-    include: {
-      payment: true,
-      user: true,
-      attendees: true,
-      eventType: true,
-    },
-  });
+  const booking = await bookingRepository.getBookingForPaymentProcessing(input.bookingId);
 
   if (!booking) {
     throw new Error("Booking not found");
@@ -48,118 +28,16 @@ export const chargeCardHandler = async ({ ctx, input }: ChargeCardHandlerOptions
     });
   }
 
-  const tOrganizer = await getTranslation(booking.user?.locale ?? "en", "common");
-
-  const attendeesListPromises = [];
-
-  for (const attendee of booking.attendees) {
-    const attendeeObject = {
-      name: attendee.name,
-      email: attendee.email,
-      timeZone: attendee.timeZone,
-      language: {
-        translate: await getTranslation(attendee.locale ?? "en", "common"),
-        locale: attendee.locale ?? "en",
-      },
-    };
-
-    attendeesListPromises.push(attendeeObject);
-  }
-
-  const attendeesList = await Promise.all(attendeesListPromises);
-
-  const evt: CalendarEvent = {
-    type: (booking?.eventType?.title as string) || booking?.title,
-    title: booking.title,
-    startTime: dayjs(booking.startTime).format(),
-    endTime: dayjs(booking.endTime).format(),
-    organizer: {
-      email: booking?.userPrimaryEmail ?? booking.user?.email ?? "",
-      name: booking.user?.name || "Nameless",
-      timeZone: booking.user?.timeZone || "",
-      language: { translate: tOrganizer, locale: booking.user?.locale ?? "en" },
-    },
-    attendees: attendeesList,
-    hideOrganizerEmail: booking.eventType?.hideOrganizerEmail,
-    paymentInfo: {
-      amount: booking.payment[0].amount,
-      currency: booking.payment[0].currency,
-      paymentOption: booking.payment[0].paymentOption,
-    },
-  };
-
-  const userId = ctx.user.id;
-  const teamId = booking.eventType?.teamId;
-  const appId = booking.payment[0].appId;
-
-  if (teamId) {
-    const userIsInTeam = await MembershipRepository.findUniqueByUserIdAndTeamId({
-      userId,
-      teamId,
-    });
-
-    if (!userIsInTeam) {
-      throw new TRPCError({ code: "UNAUTHORIZED", message: "User is not in team" });
-    }
-  }
-
-  let paymentCredential = await CredentialRepository.findPaymentCredentialByAppIdAndUserIdOrTeamId({
-    appId,
-    userId,
-    teamId,
-  });
-
-  if (!paymentCredential && teamId) {
-    // See if the team event belongs to an org
-    const org = await teamRepository.findParentOrganizationByTeamId(teamId);
-
-    if (org) {
-      paymentCredential = await CredentialRepository.findPaymentCredentialByAppIdAndTeamId({
-        appId,
-        teamId: org.id,
-      });
-    }
-  }
-
-  if (!paymentCredential?.app) {
-    throw new TRPCError({ code: "BAD_REQUEST", message: "Invalid payment credential" });
-  }
-
-  const key = paymentCredential?.app?.dirName;
-  const paymentAppImportFn = PaymentServiceMap[key as keyof typeof PaymentServiceMap];
-  if (!paymentAppImportFn) {
-    throw new TRPCError({ code: "BAD_REQUEST", message: "Payment app not implemented" });
-  }
-
-  const paymentApp = await paymentAppImportFn;
-  if (!paymentApp?.PaymentService) {
-    throw new TRPCError({ code: "BAD_REQUEST", message: "Payment service not found" });
-  }
-  const PaymentService = paymentApp.PaymentService;
-  const paymentInstance = new PaymentService(paymentCredential) as IAbstractPaymentService;
-
   try {
-    const paymentData = await paymentInstance.chargeCard(booking.payment[0], booking.id);
-
-    if (!paymentData) {
-      throw new TRPCError({ code: "NOT_FOUND", message: `Could not generate payment data` });
-    }
-
-    await sendNoShowFeeChargedEmail(
-      attendeesListPromises[0],
-      evt,
-      booking?.eventType?.metadata as EventTypeMetadata
-    );
-
-    return paymentData;
-  } catch (err) {
-    let errorMessage = `Error processing payment with error ${err}`;
-    if (err instanceof ErrorWithCode && err.code === ErrorCode.ChargeCardFailure) {
-      errorMessage = err.message;
-    }
+    await handleNoShowFee({
+      booking,
+      payment: booking.payment[0],
+    });
+  } catch (error) {
+    console.error(error);
     throw new TRPCError({
-      code: "BAD_REQUEST",
-      message: tOrganizer(errorMessage),
+      code: "INTERNAL_SERVER_ERROR",
+      message: `Failed to charge no show fee for ${booking.id}`,
     });
   }
 };