diff --git a/apps/web/components/booking/BookingListItem.tsx b/apps/web/components/booking/BookingListItem.tsx
index f673aa9f6440fb..5a196c860a5002 100644
--- a/apps/web/components/booking/BookingListItem.tsx
+++ b/apps/web/components/booking/BookingListItem.tsx
@@ -52,6 +52,7 @@ import { AddGuestsDialog } from "@components/dialog/AddGuestsDialog";
 import { ChargeCardDialog } from "@components/dialog/ChargeCardDialog";
 import { EditLocationDialog } from "@components/dialog/EditLocationDialog";
 import { ReassignDialog } from "@components/dialog/ReassignDialog";
+import { RemoveBookingSeatsDialog } from "@components/dialog/RemoveBookingSeatsDialog";
 import { RerouteDialog } from "@components/dialog/RerouteDialog";
 import { RescheduleDialog } from "@components/dialog/RescheduleDialog";
 
@@ -70,15 +71,24 @@ type BookingListingStatus = RouterInputs["viewer"]["bookings"]["get"]["filters"]
 
 type BookingItem = RouterOutputs["viewer"]["bookings"]["get"]["bookings"][number];
 
+type LoggedInUser = {
+  userId: number | undefined;
+  userTimeZone: string | undefined;
+  userTimeFormat: number | null | undefined;
+  userEmail: string | undefined;
+  userIsOrgAdminOrOwner: boolean | undefined;
+  teamsWhereUserIsAdminOrOwner:
+    | {
+        id: number;
+        teamId: number;
+      }[]
+    | undefined;
+};
+
 export type BookingItemProps = BookingItem & {
   listingStatus: BookingListingStatus;
   recurringInfo: RouterOutputs["viewer"]["bookings"]["get"]["recurringInfo"][number] | undefined;
-  loggedInUser: {
-    userId: number | undefined;
-    userTimeZone: string | undefined;
-    userTimeFormat: number | null | undefined;
-    userEmail: string | undefined;
-  };
+  loggedInUser: LoggedInUser;
   isToday: boolean;
 };
 
@@ -194,6 +204,30 @@ function BookingListItem(booking: BookingItemProps) {
   const location = booking.location as ReturnType<typeof getEventLocationValue>;
   const locationVideoCallUrl = parsedBooking.metadata?.videoCallUrl;
 
+  const checkIfUserIsHost = (userId?: number | null) => {
+    if (!userId) return false;
+
+    return (
+      booking.user?.id === userId ||
+      booking.eventType.hosts?.some(
+        (host) =>
+          host.user?.id === userId &&
+          booking.attendees.some((attendee) => attendee.email === host.user?.email)
+      )
+    );
+  };
+
+  const checkIfUserIsAuthorizedToCancelSeats = () => {
+    const { user, eventType } = booking;
+    const { userId, userIsOrgAdminOrOwner, teamsWhereUserIsAdminOrOwner } = booking.loggedInUser;
+    const isUserOwner = user?.id === userId;
+    const isUserTeamEventHost = checkIfUserIsHost(userId);
+    const isUserTeamAdminOrOwner = teamsWhereUserIsAdminOrOwner?.some(
+      (team) => team.teamId === eventType?.team?.id || team.teamId === eventType?.parent?.teamId
+    );
+    return isUserOwner || isUserTeamEventHost || userIsOrgAdminOrOwner || isUserTeamAdminOrOwner;
+  };
+
   const { resolvedTheme, forcedTheme } = useGetTheme();
   const hasDarkTheme = !forcedTheme && resolvedTheme === "dark";
   const eventTypeColor =
@@ -255,6 +289,7 @@ function BookingListItem(booking: BookingItemProps) {
     cardCharged,
     attendeeList,
     getSeatReferenceUid,
+    checkIfUserIsAuthorizedToCancelSeats,
     t,
   } as BookingActionContext;
 
@@ -293,6 +328,7 @@ function BookingListItem(booking: BookingItemProps) {
   const [isOpenSetLocationDialog, setIsOpenLocationDialog] = useState(false);
   const [isOpenAddGuestsDialog, setIsOpenAddGuestsDialog] = useState(false);
   const [rerouteDialogIsOpen, setRerouteDialogIsOpen] = useState(false);
+  const [isOpenRemoveSeatsDialog, setIsOpenRemoveSeatsDialog] = useState(false);
   const setLocationMutation = trpc.viewer.bookings.editLocation.useMutation({
     onSuccess: () => {
       showToast(t("location_updated"), "success");
@@ -368,6 +404,8 @@ function BookingListItem(booking: BookingItemProps) {
         ? () => setIsOpenLocationDialog(true)
         : action.id === "add_members"
         ? () => setIsOpenAddGuestsDialog(true)
+        : action.id === "remove_seats"
+        ? () => setIsOpenRemoveSeatsDialog(true)
         : action.id === "reassign"
         ? () => setIsOpenReassignDialog(true)
         : undefined,
@@ -430,6 +468,20 @@ function BookingListItem(booking: BookingItemProps) {
         setIsOpenDialog={setIsOpenAddGuestsDialog}
         bookingId={booking.id}
       />
+      {checkIfUserIsAuthorizedToCancelSeats() && (
+        <RemoveBookingSeatsDialog
+          isOpenDialog={isOpenRemoveSeatsDialog}
+          setIsOpenDialog={setIsOpenRemoveSeatsDialog}
+          bookingUid={booking.uid}
+          attendees={booking.seatsReferences
+            .map((seat) => ({
+              email: seat.attendee?.email || "",
+              name: seat.attendee?.name || null,
+              referenceUid: seat.referenceUid,
+            }))
+            .filter((attendee) => attendee.email)}
+        />
+      )}
       {booking.paid && booking.payment[0] && (
         <ChargeCardDialog
           isOpenDialog={chargeCardDialogIsOpen}
diff --git a/apps/web/components/booking/bookingActions.ts b/apps/web/components/booking/bookingActions.ts
index f98e99266a5d2a..7b4902122e4300 100644
--- a/apps/web/components/booking/bookingActions.ts
+++ b/apps/web/components/booking/bookingActions.ts
@@ -23,6 +23,7 @@ export interface BookingActionContext {
   showPendingPayment: boolean;
   isAttendee: boolean;
   cardCharged: boolean;
+  checkIfUserIsAuthorizedToCancelSeats: () => boolean;
   attendeeList: Array<{
     name: string;
     email: string;
@@ -104,6 +105,7 @@ export function getEditEventActions(context: BookingActionContext): ActionType[]
     isBookingFromRoutingForm,
     getSeatReferenceUid,
     isAttendee,
+    checkIfUserIsAuthorizedToCancelSeats,
     t,
   } = context;
 
@@ -148,6 +150,14 @@ export function getEditEventActions(context: BookingActionContext): ActionType[]
           icon: "user-plus",
           disabled: false,
         },
+    booking.seatsReferences.length > 0 && !isBookingInPast && checkIfUserIsAuthorizedToCancelSeats()
+      ? {
+          id: "remove_seats",
+          label: t("remove_seats"),
+          icon: "user-x",
+          disabled: false,
+        }
+      : null,
     // Reassign if round robin with no or one host groups
     booking.eventType.schedulingType === SchedulingType.ROUND_ROBIN &&
     (!booking.eventType.hostGroups || booking.eventType.hostGroups?.length <= 1)
diff --git a/apps/web/components/dialog/RemoveBookingSeatsDialog.tsx b/apps/web/components/dialog/RemoveBookingSeatsDialog.tsx
new file mode 100644
index 00000000000000..93c07376ea1890
--- /dev/null
+++ b/apps/web/components/dialog/RemoveBookingSeatsDialog.tsx
@@ -0,0 +1,164 @@
+import { useSession } from "next-auth/react";
+import type { Dispatch, SetStateAction } from "react";
+import { useState } from "react";
+
+import { Dialog } from "@calcom/features/components/controlled-dialog";
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { trpc } from "@calcom/trpc/react";
+import { Button } from "@calcom/ui/components/button";
+import { DialogContent, DialogFooter, DialogHeader } from "@calcom/ui/components/dialog";
+import { Label, Select, TextArea } from "@calcom/ui/components/form";
+import type { Option } from "@calcom/ui/components/form/checkbox/MultiSelectCheckboxes";
+import { Icon } from "@calcom/ui/components/icon";
+import { showToast } from "@calcom/ui/components/toast";
+
+type SeatOption = Option & {
+  data: {
+    referenceUid: string | null;
+    email: string;
+    name: string | null;
+  };
+};
+
+interface IRemoveBookingSeatsDialog {
+  isOpenDialog: boolean;
+  setIsOpenDialog: Dispatch<SetStateAction<boolean>>;
+  bookingUid: string;
+  attendees: {
+    email: string;
+    name?: string | null;
+    referenceUid?: string;
+  }[];
+}
+
+export const RemoveBookingSeatsDialog = (props: IRemoveBookingSeatsDialog) => {
+  const { t } = useLocale();
+  const { isOpenDialog, setIsOpenDialog, bookingUid, attendees } = props;
+  const { data: session } = useSession();
+  const utils = trpc.useUtils();
+  const [selectedOptions, setSelectedOptions] = useState<SeatOption[]>([]);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [cancellationReason, setCancellationReason] = useState<string>("");
+
+  const handleRemove = async () => {
+    setIsSubmitting(true);
+
+    const seatReferenceUids = selectedOptions.map((option) => option.data.referenceUid).filter(Boolean);
+
+    try {
+      const res = await fetch("/api/cancel", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          uid: bookingUid,
+          seatReferenceUid: seatReferenceUids,
+          cancellationReason: cancellationReason,
+          cancelledBy: session?.user?.email || undefined,
+        }),
+      });
+
+      if (res.ok) {
+        showToast(t("seats_removed"), "success");
+        setIsOpenDialog(false);
+        setSelectedOptions([]);
+        utils.viewer.bookings.invalidate();
+      } else {
+        showToast(t("error_removing_seats"), "error");
+      }
+    } catch (error) {
+      console.error("Error removing seats", error);
+      showToast(t("error_removing_seats"), "error");
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
+  const selectOptions = attendees.map((attendee) => ({
+    label: attendee.name ? `${attendee.name}` : attendee.email,
+    value: attendee.email,
+    data: {
+      referenceUid: attendee.referenceUid || null,
+      email: attendee.email,
+      name: attendee.name || null,
+    },
+  })) as SeatOption[];
+
+  if (selectOptions.length === 0) {
+    return null;
+  }
+
+  return (
+    <Dialog open={isOpenDialog} onOpenChange={setIsOpenDialog}>
+      <DialogContent className="flex flex-col">
+        <div className="flex-grow">
+          <div className="flex flex-row space-x-3">
+            <div className="bg-subtle flex h-10 w-10 flex-shrink-0 justify-center rounded-full">
+              <Icon name="user-x" className="m-auto h-6 w-6" />
+            </div>
+            <div className="w-full pt-1">
+              <DialogHeader title={t("remove_seats")} />
+              <div className="bg-default pb-4">
+                {selectOptions.length > 0 ? (
+                  <div style={{ position: "relative", zIndex: 1 }}>
+                    <Select
+                      isMulti
+                      grow
+                      options={selectOptions}
+                      value={selectedOptions}
+                      onChange={(newValue) => setSelectedOptions([...newValue])}
+                      placeholder={t("select_seats")}
+                      closeMenuOnSelect={false}
+                    />
+                  </div>
+                ) : (
+                  <div className="text-default py-2">{t("no_seats_available")}</div>
+                )}
+
+                <div className="mt-4">
+                  <Label>{t("cancellation_reason_host")}</Label>
+                  <TextArea
+                    data-testid="cancellation_reason_host"
+                    name="cancellationReason"
+                    value={cancellationReason}
+                    onChange={(e) => setCancellationReason(e.target.value)}
+                    className="mb-2 mt-2 w-full"
+                    rows={3}
+                    placeholder={t("cancellation_reason_placeholder")}
+                  />
+                  <div className="flex items-center gap-2">
+                    <Icon name="info" className="text-subtle h-4 w-4" />
+                    <p className="text-subtle text-sm leading-none">
+                      {t("notify_attendee_cancellation_reason_warning")}
+                    </p>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+          <DialogFooter showDivider className="mt-8">
+            <Button
+              onClick={() => {
+                setSelectedOptions([]);
+                setCancellationReason("");
+                setIsOpenDialog(false);
+              }}
+              type="button"
+              color="secondary"
+              disabled={isSubmitting}>
+              {t("cancel")}
+            </Button>
+            <Button
+              data-testid="remove_seats"
+              loading={isSubmitting}
+              disabled={selectedOptions.length === 0 || !cancellationReason}
+              onClick={handleRemove}>
+              {t("remove")}
+            </Button>
+          </DialogFooter>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+};
diff --git a/apps/web/modules/bookings/views/bookings-listing-view.tsx b/apps/web/modules/bookings/views/bookings-listing-view.tsx
index c4ccbab26e819b..b524ca7367267f 100644
--- a/apps/web/modules/bookings/views/bookings-listing-view.tsx
+++ b/apps/web/modules/bookings/views/bookings-listing-view.tsx
@@ -295,6 +295,8 @@ function BookingsContent({ status, permissions }: BookingsProps) {
                   userTimeZone: user?.timeZone,
                   userTimeFormat: user?.timeFormat,
                   userEmail: user?.email,
+                  teamsWhereUserIsAdminOrOwner: user?.teamsWhereUserIsAdminOrOwner,
+                  userIsOrgAdminOrOwner: user?.organization?.isOrgAdmin,
                 }}
                 listingStatus={status}
                 recurringInfo={recurringInfo}
diff --git a/apps/web/public/static/locales/en/common.json b/apps/web/public/static/locales/en/common.json
index e10c43eff99b58..ff67aa234c98b2 100644
--- a/apps/web/public/static/locales/en/common.json
+++ b/apps/web/public/static/locales/en/common.json
@@ -653,6 +653,10 @@
   "all_booked_today": "All booked.",
   "slots_load_fail": "Could not load the available time slots.",
   "additional_guests": "Add guests",
+  "remove_seats": "Remove seats",
+  "seats_removed": "Seats removed successfully",
+  "error_removing_seats": "Error removing seats",
+  "select_seats": "Select seats",
   "your_name": "Your name",
   "your_full_name": "Your full name",
   "no_name": "No name",
@@ -2185,6 +2189,7 @@
   "attendee_no_longer_attending_subject": "An attendee is no longer attending {{title}} at {{date}}",
   "attendee_no_longer_attending": "An attendee is no longer attending your event",
   "attendee_no_longer_attending_subtitle": "{{name}} has canceled. This means a seat has opened up for this time slot",
+  "attendee_removed_subtitle": "{{name}} was removed. This means a seat has opened up for this time slot",
   "create_event_on": "Create event on",
   "create_routing_form_on": "Create routing form on",
   "default_app_link_title": "Set a default app link",
diff --git a/packages/emails/email-manager.ts b/packages/emails/email-manager.ts
index 74463692c4efac..e6e2a6efcce3aa 100644
--- a/packages/emails/email-manager.ts
+++ b/packages/emails/email-manager.ts
@@ -389,14 +389,19 @@ export const sendScheduledSeatsEmailsAndSMS = async (
 export const sendCancelledSeatEmailsAndSMS = async (
   calEvent: CalendarEvent,
   cancelledAttendee: Person,
-  eventTypeMetadata?: EventTypeMetadata
+  eventTypeMetadata?: EventTypeMetadata,
+  isCancelledByHost?: boolean
 ) => {
   const formattedCalEvent = formatCalEvent(calEvent);
   const clonedCalEvent = cloneDeep(formattedCalEvent);
   const emailsToSend: Promise<unknown>[] = [];
 
   if (!eventTypeDisableAttendeeEmail(eventTypeMetadata))
-    emailsToSend.push(sendEmail(() => new AttendeeCancelledSeatEmail(clonedCalEvent, cancelledAttendee)));
+    emailsToSend.push(
+      sendEmail(
+        () => new AttendeeCancelledSeatEmail(clonedCalEvent, cancelledAttendee, undefined, isCancelledByHost)
+      )
+    );
   if (!eventTypeDisableHostEmail(eventTypeMetadata))
     emailsToSend.push(
       sendEmail(
@@ -404,6 +409,7 @@ export const sendCancelledSeatEmailsAndSMS = async (
           new OrganizerAttendeeCancelledSeatEmail({
             calEvent: formattedCalEvent,
             attendee: cancelledAttendee,
+            isCancelledByHost,
           })
       )
     );
diff --git a/packages/emails/src/templates/AttendeeCancelledSeatEmail.tsx b/packages/emails/src/templates/AttendeeCancelledSeatEmail.tsx
index fefcdfa2e0f0af..edd6ee67b16182 100644
--- a/packages/emails/src/templates/AttendeeCancelledSeatEmail.tsx
+++ b/packages/emails/src/templates/AttendeeCancelledSeatEmail.tsx
@@ -1,12 +1,15 @@
 import { AttendeeScheduledEmail } from "./AttendeeScheduledEmail";
 
-export const AttendeeCancelledSeatEmail = (props: React.ComponentProps<typeof AttendeeScheduledEmail>) => (
-  <AttendeeScheduledEmail
-    title="no_longer_attending"
-    headerType="xCircle"
-    subject="event_no_longer_attending_subject"
-    subtitle=""
-    callToAction={null}
-    {...props}
-  />
-);
+export const AttendeeCancelledSeatEmail = (props: React.ComponentProps<typeof AttendeeScheduledEmail>) => {
+  const title = props.isCancelledByHost ? "event_request_cancelled" : "no_longer_attending";
+  return (
+    <AttendeeScheduledEmail
+      title={title}
+      headerType="xCircle"
+      subject="event_no_longer_attending_subject"
+      subtitle=""
+      callToAction={null}
+      {...props}
+    />
+  );
+};
diff --git a/packages/emails/src/templates/AttendeeScheduledEmail.tsx b/packages/emails/src/templates/AttendeeScheduledEmail.tsx
index b1497cd3f9b954..d52dab27809f9e 100644
--- a/packages/emails/src/templates/AttendeeScheduledEmail.tsx
+++ b/packages/emails/src/templates/AttendeeScheduledEmail.tsx
@@ -6,6 +6,7 @@ export const AttendeeScheduledEmail = (
   props: {
     calEvent: CalendarEvent;
     attendee: Person;
+    isCancelledByHost?: boolean;
   } & Partial<React.ComponentProps<typeof BaseScheduledEmail>>
 ) => {
   return (
diff --git a/packages/emails/src/templates/OrganizerAttendeeCancelledSeatEmail.tsx b/packages/emails/src/templates/OrganizerAttendeeCancelledSeatEmail.tsx
index 873230671d232f..3923ac5dc2aa2d 100644
--- a/packages/emails/src/templates/OrganizerAttendeeCancelledSeatEmail.tsx
+++ b/packages/emails/src/templates/OrganizerAttendeeCancelledSeatEmail.tsx
@@ -8,7 +8,7 @@ export const OrganizerAttendeeCancelledSeatEmail = (
     headerType="xCircle"
     subject="event_cancelled_subject"
     callToAction={null}
-    attendeeCancelled
+    attendeeCancelled={!props.isCancelledByHost}
     {...props}
   />
 );
diff --git a/packages/emails/src/templates/OrganizerScheduledEmail.tsx b/packages/emails/src/templates/OrganizerScheduledEmail.tsx
index 9d6e5c18313b11..969c34cc633ac8 100644
--- a/packages/emails/src/templates/OrganizerScheduledEmail.tsx
+++ b/packages/emails/src/templates/OrganizerScheduledEmail.tsx
@@ -11,11 +11,11 @@ export const OrganizerScheduledEmail = (
     attendeeCancelled?: boolean;
     teamMember?: Person;
     reassigned?: { name: string | null; email: string; reason?: string; byUser?: string };
+    isCancelledByHost?: boolean;
   } & Partial<React.ComponentProps<typeof BaseScheduledEmail>>
 ) => {
   let subject;
   let title;
-
   if (props.newSeat) {
     subject = "new_seat_subject";
   } else {
@@ -39,6 +39,12 @@ export const OrganizerScheduledEmail = (
     props.calEvent.schedulingType === SchedulingType.COLLECTIVE;
   const attendee = isTeamEvent && props.teamMember ? props.teamMember : props.attendee;
 
+  const subtitle = props.attendeeCancelled
+    ? t("attendee_no_longer_attending_subtitle", { name: props.attendee.name })
+    : props.isCancelledByHost
+    ? t("attendee_removed_subtitle", { name: props.attendee.name })
+    : "";
+
   return (
     <BaseScheduledEmail
       locale={locale}
@@ -49,17 +55,7 @@ export const OrganizerScheduledEmail = (
       includeAppsStatus
       timeFormat={timeFormat}
       isOrganizer
-      subtitle={
-        props.subtitle ? (
-          props.subtitle
-        ) : (
-          <>
-            {props.attendeeCancelled
-              ? t("attendee_no_longer_attending_subtitle", { name: props.attendee.name })
-              : ""}
-          </>
-        )
-      }
+      subtitle={props.subtitle ? props.subtitle : <>{subtitle}</>}
       reassigned={props.reassigned}
       {...props}
       attendee={attendee}
diff --git a/packages/emails/templates/attendee-cancelled-seat-email.ts b/packages/emails/templates/attendee-cancelled-seat-email.ts
index 590ce65d6e11ff..755db331a642b1 100644
--- a/packages/emails/templates/attendee-cancelled-seat-email.ts
+++ b/packages/emails/templates/attendee-cancelled-seat-email.ts
@@ -16,6 +16,7 @@ export default class AttendeeCancelledSeatEmail extends AttendeeScheduledEmail {
       html: await renderEmail("AttendeeCancelledSeatEmail", {
         calEvent: this.calEvent,
         attendee: this.attendee,
+        isCancelledByHost: this.isCancelledByHost,
       }),
       text: this.getTextBody("event_request_cancelled", "emailed_you_and_any_other_attendees"),
     };
diff --git a/packages/emails/templates/attendee-scheduled-email.ts b/packages/emails/templates/attendee-scheduled-email.ts
index 6f54588d274163..87473cfd0b164b 100644
--- a/packages/emails/templates/attendee-scheduled-email.ts
+++ b/packages/emails/templates/attendee-scheduled-email.ts
@@ -15,8 +15,14 @@ export default class AttendeeScheduledEmail extends BaseEmail {
   attendee: Person;
   showAttendees: boolean | undefined;
   t: TFunction;
+  isCancelledByHost?: boolean;
 
-  constructor(calEvent: CalendarEvent, attendee: Person, showAttendees?: boolean | undefined) {
+  constructor(
+    calEvent: CalendarEvent,
+    attendee: Person,
+    showAttendees?: boolean | undefined,
+    isCancelledByHost?: boolean
+  ) {
     super();
     if (!showAttendees && calEvent.seatsPerTimeSlot) {
       this.calEvent = cloneDeep(calEvent);
@@ -27,6 +33,7 @@ export default class AttendeeScheduledEmail extends BaseEmail {
     this.name = "SEND_BOOKING_CONFIRMATION";
     this.attendee = attendee;
     this.t = attendee.language.translate;
+    this.isCancelledByHost = isCancelledByHost;
   }
 
   protected async getNodeMailerPayload(): Promise<Record<string, unknown>> {
diff --git a/packages/emails/templates/organizer-attendee-cancelled-seat-email.ts b/packages/emails/templates/organizer-attendee-cancelled-seat-email.ts
index 4ff6020d28eedc..bcc03bb114a24e 100644
--- a/packages/emails/templates/organizer-attendee-cancelled-seat-email.ts
+++ b/packages/emails/templates/organizer-attendee-cancelled-seat-email.ts
@@ -25,6 +25,7 @@ export default class OrganizerCancelledEmail extends OrganizerScheduledEmail {
       html: await renderEmail("OrganizerAttendeeCancelledSeatEmail", {
         attendee: this.attendee || this.calEvent.organizer,
         calEvent: this.calEvent,
+        isCancelledByHost: this.isCancelledByHost,
       }),
       text: this.getTextBody("event_request_cancelled"),
     };
diff --git a/packages/emails/templates/organizer-scheduled-email.ts b/packages/emails/templates/organizer-scheduled-email.ts
index 88f201e030093a..4b404da115c3f2 100644
--- a/packages/emails/templates/organizer-scheduled-email.ts
+++ b/packages/emails/templates/organizer-scheduled-email.ts
@@ -20,6 +20,7 @@ export default class OrganizerScheduledEmail extends BaseEmail {
   teamMember?: Person;
   reassigned?: Reassigned;
   attendee?: Person;
+  isCancelledByHost?: boolean;
 
   constructor(input: {
     calEvent: CalendarEvent;
@@ -27,6 +28,7 @@ export default class OrganizerScheduledEmail extends BaseEmail {
     teamMember?: Person;
     reassigned?: Reassigned;
     attendee?: Person;
+    isCancelledByHost?: boolean;
   }) {
     super();
     this.name = "SEND_BOOKING_CONFIRMATION";
@@ -36,6 +38,7 @@ export default class OrganizerScheduledEmail extends BaseEmail {
     this.teamMember = input.teamMember;
     this.reassigned = input.reassigned;
     this.attendee = input.attendee;
+    this.isCancelledByHost = input.isCancelledByHost;
   }
 
   protected async getNodeMailerPayload(): Promise<Record<string, unknown>> {
diff --git a/packages/features/bookings/lib/handleCancelBooking.ts b/packages/features/bookings/lib/handleCancelBooking.ts
index 12f6b60c85eaab..7ef5a77ab68617 100644
--- a/packages/features/bookings/lib/handleCancelBooking.ts
+++ b/packages/features/bookings/lib/handleCancelBooking.ts
@@ -131,6 +131,8 @@ async function handler(input: CancelBookingInput) {
     });
   }
 
+  const seatsToCancel = seatReferenceUid ? [seatReferenceUid].flat() : [];
+
   // If the booking is a seated event and there is no seatReferenceUid we should validate that logged in user is host
   if (bookingToDelete.eventType?.seatsPerTimeSlot && !seatReferenceUid) {
     const userIsHost = bookingToDelete.eventType.hosts.find((host) => {
@@ -303,7 +305,7 @@ async function handler(input: CancelBookingInput) {
   // If it's just an attendee of a booking then just remove them from that booking
   const result = await cancelAttendeeSeat(
     {
-      seatReferenceUid: seatReferenceUid,
+      seatReferenceUid: seatsToCancel,
       bookingToDelete,
     },
     dataForWebhooks,
diff --git a/packages/features/bookings/lib/handleSeats/cancel/cancelAttendeeSeat.ts b/packages/features/bookings/lib/handleSeats/cancel/cancelAttendeeSeat.ts
index 1a59292c841e0b..105d9d4387392d 100644
--- a/packages/features/bookings/lib/handleSeats/cancel/cancelAttendeeSeat.ts
+++ b/packages/features/bookings/lib/handleSeats/cancel/cancelAttendeeSeat.ts
@@ -21,7 +21,7 @@ import type { BookingToDelete } from "../../handleCancelBooking";
 
 async function cancelAttendeeSeat(
   data: {
-    seatReferenceUid?: string;
+    seatReferenceUid?: string | string[];
     bookingToDelete: BookingToDelete;
   },
   dataForWebhooks: {
@@ -44,32 +44,47 @@ async function cancelAttendeeSeat(
   if (!input.success) return;
   const { seatReferenceUid } = input.data;
   const bookingToDelete = data.bookingToDelete;
-  if (!bookingToDelete?.attendees.length || bookingToDelete.attendees.length < 2) return;
+
+  const seatsToCancel = Array.from(new Set(seatReferenceUid ? [seatReferenceUid].flat() : []));
+
+  const shouldCancelAllSeats =
+    seatsToCancel.length === 0 || seatsToCancel.length >= bookingToDelete.attendees.length;
+
+  // Return if user is trying to delete all attendees
+  if (shouldCancelAllSeats) {
+    return;
+  }
 
   if (!bookingToDelete.userId) {
     throw new HttpError({ statusCode: 400, message: "User not found" });
   }
 
-  const seatReference = bookingToDelete.seatsReferences.find(
-    (reference) => reference.referenceUid === seatReferenceUid
+  const seatReferences = bookingToDelete.seatsReferences.filter((reference) =>
+    seatsToCancel.includes(reference.referenceUid)
   );
 
-  if (!seatReference) throw new HttpError({ statusCode: 400, message: "User not a part of this booking" });
+  if (seatReferences.length !== seatsToCancel.length) {
+    throw new HttpError({ statusCode: 400, message: "One or more seats are not part of this booking" });
+  }
 
   await Promise.all([
-    prisma.bookingSeat.delete({
+    prisma.bookingSeat.deleteMany({
       where: {
-        referenceUid: seatReferenceUid,
+        referenceUid: { in: seatsToCancel },
       },
     }),
-    prisma.attendee.delete({
+    prisma.attendee.deleteMany({
       where: {
-        id: seatReference.attendeeId,
+        id: {
+          in: seatReferences.map((reference) => reference?.attendeeId),
+        },
       },
     }),
   ]);
 
-  const attendee = bookingToDelete?.attendees.find((attendee) => attendee.id === seatReference.attendeeId);
+  const attendees = bookingToDelete?.attendees.filter((attendee) =>
+    seatReferences.some((reference) => reference?.attendeeId === attendee.id)
+  );
   const bookingToDeleteUser = bookingToDelete.user ?? null;
   const delegationCredentials = bookingToDeleteUser
     ? // We fetch delegation credentials with ServiceAccount key as CalendarService instance created later in the flow needs it
@@ -78,7 +93,7 @@ async function cancelAttendeeSeat(
       })
     : [];
 
-  if (attendee) {
+  if (attendees.length > 0) {
     /* If there are references then we should update them as well */
 
     const integrationsToUpdate = [];
@@ -94,9 +109,12 @@ async function cancelAttendeeSeat(
         });
 
         if (credential) {
+          const remainingAttendees = evt.attendees.filter(
+            (evtAttendee) => !attendees.some((attendee) => attendee.email === evtAttendee.email)
+          );
           const updatedEvt = {
             ...evt,
-            attendees: evt.attendees.filter((evtAttendee) => attendee.email !== evtAttendee.email),
+            attendees: remainingAttendees,
             calendarDescription: getRichDescription(evt),
           };
           if (reference.type.includes("_video")) {
@@ -121,29 +139,30 @@ async function cancelAttendeeSeat(
       // as integrations was already updated
     }
 
-    const tAttendees = await getTranslation(attendee.locale ?? "en", "common");
+    const tAttendees = await getTranslation(attendees[0].locale ?? "en", "common");
 
-    await sendCancelledSeatEmailsAndSMS(
-      evt,
-      {
-        ...attendee,
-        language: { translate: tAttendees, locale: attendee.locale ?? "en" },
-      },
-      eventTypeMetadata
-    );
-  }
-
-  evt.attendees = attendee
-    ? [
+    for (const attendee of attendees) {
+      await sendCancelledSeatEmailsAndSMS(
+        evt,
         {
           ...attendee,
-          language: {
-            translate: await getTranslation(attendee.locale ?? "en", "common"),
-            locale: attendee.locale ?? "en",
-          },
+          language: { translate: tAttendees, locale: attendee.locale ?? "en" },
         },
-      ]
-    : [];
+        eventTypeMetadata,
+        true
+      );
+    }
+
+    evt.attendees = await Promise.all(
+      attendees.map(async (attendee) => ({
+        ...attendee,
+        language: {
+          translate: await getTranslation(attendee.locale ?? "en", "common"),
+          locale: attendee.locale ?? "en",
+        },
+      }))
+    );
+  }
 
   const payload: EventPayloadType = {
     ...evt,
diff --git a/packages/features/bookings/lib/handleSeats/test/handleSeats.test.ts b/packages/features/bookings/lib/handleSeats/test/handleSeats.test.ts
index 6198cd3d5d3d35..a2621beada53c7 100644
--- a/packages/features/bookings/lib/handleSeats/test/handleSeats.test.ts
+++ b/packages/features/bookings/lib/handleSeats/test/handleSeats.test.ts
@@ -2666,6 +2666,428 @@ describe("handleSeats", () => {
         expect(cancelledBooking?.status).toEqual(BookingStatus.CANCELLED);
         expect(cancelledBooking?.cancelledBy).toEqual(organizer.email);
       });
+
+      test("When all seats are cancelled, the booking is cancelled", async () => {
+        const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking"))
+          .default;
+
+        const organizer = getOrganizer({
+          name: "Organizer",
+          email: "organizer@example.com",
+          id: 101,
+          schedules: [TestData.schedules.IstWorkHours],
+        });
+
+        const bookingId = 1;
+        const bookingUid = "abc123";
+        const { dateString: plus1DateString } = getDate({ dateIncrement: 1 });
+        const bookingStartTime = `${plus1DateString}T04:00:00Z`;
+        const bookingEndTime = `${plus1DateString}T04:30:00Z`;
+
+        await createBookingScenario(
+          getScenarioData({
+            eventTypes: [
+              {
+                id: 1,
+                slug: "seated-event",
+                slotInterval: 30,
+                length: 30,
+                users: [
+                  {
+                    id: 101,
+                  },
+                ],
+                seatsPerTimeSlot: 4,
+                seatsShowAttendees: false,
+                owner: organizer.id,
+              },
+            ],
+            bookings: [
+              {
+                id: bookingId,
+                uid: bookingUid,
+                eventTypeId: 1,
+                userId: organizer.id,
+                status: BookingStatus.ACCEPTED,
+                startTime: bookingStartTime,
+                endTime: bookingEndTime,
+                metadata: {
+                  videoCallUrl: "https://existing-daily-video-call-url.example.com",
+                },
+                references: [
+                  {
+                    type: appStoreMetadata.dailyvideo.type,
+                    uid: "MOCK_ID",
+                    meetingId: "MOCK_ID",
+                    meetingPassword: "MOCK_PASS",
+                    meetingUrl: "http://mock-dailyvideo.example.com",
+                    credentialId: null,
+                  },
+                ],
+                attendees: [
+                  getMockBookingAttendee({
+                    id: 1,
+                    name: "Seat 1",
+                    email: "seat1@test.com",
+                    locale: "en",
+                    timeZone: "America/Toronto",
+                    bookingSeat: {
+                      referenceUid: "booking-seat-1",
+                      data: {},
+                    },
+                  }),
+                  getMockBookingAttendee({
+                    id: 2,
+                    name: "Seat 2",
+                    email: "seat2@test.com",
+                    locale: "en",
+                    timeZone: "America/Toronto",
+                    bookingSeat: {
+                      referenceUid: "booking-seat-2",
+                      data: {},
+                    },
+                  }),
+                ],
+              },
+            ],
+            organizer,
+          })
+        );
+
+        mockSuccessfulVideoMeetingCreation({
+          metadataLookupKey: "dailyvideo",
+          videoMeetingData: {
+            id: "MOCK_ID",
+            password: "MOCK_PASS",
+            url: `http://mock-dailyvideo.example.com/meeting-1`,
+          },
+        });
+
+        const mockCancelBookingData = {
+          uid: bookingUid,
+          seatReferenceUid: ["booking-seat-1", "booking-seat-2"],
+          cancellationReason: "test cancellation reason",
+        };
+
+        await handleCancelBooking({
+          bookingData: mockCancelBookingData,
+          userId: organizer.id,
+        });
+
+        // Ensure that the booking has been cancelled
+        const cancelledBooking = await prismaMock.booking.findFirst({
+          where: {
+            id: bookingId,
+          },
+          select: {
+            status: true,
+          },
+        });
+        expect(cancelledBooking?.status).toEqual(BookingStatus.CANCELLED);
+      });
+
+      test("When cancelling with mix of valid and invalid seat references, throw an error", async () => {
+        const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking"))
+          .default;
+
+        const organizer = getOrganizer({
+          name: "Organizer",
+          email: "organizer@example.com",
+          id: 101,
+          schedules: [TestData.schedules.IstWorkHours],
+        });
+
+        const bookingId = 1;
+        const bookingUid = "abc123";
+        const { dateString: plus1DateString } = getDate({ dateIncrement: 1 });
+        const bookingStartTime = `${plus1DateString}T04:00:00Z`;
+        const bookingEndTime = `${plus1DateString}T04:30:00Z`;
+
+        await createBookingScenario(
+          getScenarioData({
+            eventTypes: [
+              {
+                id: 1,
+                slug: "seated-event",
+                slotInterval: 30,
+                length: 30,
+                users: [
+                  {
+                    id: 101,
+                  },
+                ],
+                seatsPerTimeSlot: 4,
+                seatsShowAttendees: false,
+                owner: organizer.id,
+              },
+            ],
+            bookings: [
+              {
+                id: bookingId,
+                uid: bookingUid,
+                eventTypeId: 1,
+                userId: organizer.id,
+                status: BookingStatus.ACCEPTED,
+                startTime: bookingStartTime,
+                endTime: bookingEndTime,
+                metadata: {
+                  videoCallUrl: "https://existing-daily-video-call-url.example.com",
+                },
+                references: [
+                  {
+                    type: appStoreMetadata.dailyvideo.type,
+                    uid: "MOCK_ID",
+                    meetingId: "MOCK_ID",
+                    meetingPassword: "MOCK_PASS",
+                    meetingUrl: "http://mock-dailyvideo.example.com",
+                    credentialId: null,
+                  },
+                ],
+                attendees: [
+                  getMockBookingAttendee({
+                    id: 1,
+                    name: "Seat 1",
+                    email: "seat1@test.com",
+                    locale: "en",
+                    timeZone: "America/Toronto",
+                    bookingSeat: {
+                      referenceUid: "booking-seat-1",
+                      data: {},
+                    },
+                  }),
+                  getMockBookingAttendee({
+                    id: 2,
+                    name: "Seat 2",
+                    email: "seat2@test.com",
+                    locale: "en",
+                    timeZone: "America/Toronto",
+                    bookingSeat: {
+                      referenceUid: "booking-seat-2",
+                      data: {},
+                    },
+                  }),
+                  getMockBookingAttendee({
+                    id: 3,
+                    name: "Seat 3",
+                    email: "seat3@test.com",
+                    locale: "en",
+                    timeZone: "America/Toronto",
+                    bookingSeat: {
+                      referenceUid: "booking-seat-3",
+                      data: {},
+                    },
+                  }),
+                ],
+              },
+            ],
+            organizer,
+          })
+        );
+
+        mockSuccessfulVideoMeetingCreation({
+          metadataLookupKey: "dailyvideo",
+          videoMeetingData: {
+            id: "MOCK_ID",
+            password: "MOCK_PASS",
+            url: `http://mock-dailyvideo.example.com/meeting-1`,
+          },
+        });
+
+        // Mix of valid and invalid seat references
+        const mockCancelBookingData = {
+          uid: bookingUid,
+          seatReferenceUid: ["booking-seat-1", "non-existent-seat-ref"],
+          cancellationReason: "test cancellation reason",
+        };
+
+        // Expect an error to be thrown when any invalid seat references are provided
+        await expect(
+          handleCancelBooking({
+            bookingData: mockCancelBookingData,
+            userId: organizer.id,
+          })
+        ).rejects.toThrow("One or more seats are not part of this booking");
+
+        // Verify that no seats were removed (booking remains unchanged)
+        const attendees = await prismaMock.attendee.findMany({
+          where: {
+            bookingId,
+          },
+          select: {
+            id: true,
+          },
+        });
+        expect(attendees).toHaveLength(3);
+
+        const booking = await prismaMock.booking.findFirst({
+          where: {
+            id: bookingId,
+          },
+          select: {
+            status: true,
+          },
+        });
+        expect(booking?.status).toEqual(BookingStatus.ACCEPTED);
+      });
+
+      test("When multiple seats are cancelled, only remove those attendees", async () => {
+        const handleCancelBooking = (await import("@calcom/features/bookings/lib/handleCancelBooking"))
+          .default;
+
+        const organizer = getOrganizer({
+          name: "Organizer",
+          email: "organizer@example.com",
+          id: 101,
+          schedules: [TestData.schedules.IstWorkHours],
+        });
+
+        const bookingId = 1;
+        const bookingUid = "abc123";
+        const { dateString: plus1DateString } = getDate({ dateIncrement: 1 });
+        const bookingStartTime = `${plus1DateString}T04:00:00Z`;
+        const bookingEndTime = `${plus1DateString}T04:30:00Z`;
+
+        const seatRefToCancel1 = "booking-seat-1";
+        const seatRefToCancel2 = "booking-seat-2";
+
+        await createBookingScenario(
+          getScenarioData({
+            eventTypes: [
+              {
+                id: 1,
+                slug: "seated-event",
+                slotInterval: 30,
+                length: 30,
+                users: [
+                  {
+                    id: 101,
+                  },
+                ],
+                seatsPerTimeSlot: 4,
+                seatsShowAttendees: false,
+                owner: organizer.id,
+              },
+            ],
+            bookings: [
+              {
+                id: bookingId,
+                uid: bookingUid,
+                eventTypeId: 1,
+                userId: organizer.id,
+                status: BookingStatus.ACCEPTED,
+                startTime: bookingStartTime,
+                endTime: bookingEndTime,
+                metadata: {
+                  videoCallUrl: "https://existing-daily-video-call-url.example.com",
+                },
+                references: [
+                  {
+                    type: appStoreMetadata.dailyvideo.type,
+                    uid: "MOCK_ID",
+                    meetingId: "MOCK_ID",
+                    meetingPassword: "MOCK_PASS",
+                    meetingUrl: "http://mock-dailyvideo.example.com",
+                    credentialId: null,
+                  },
+                ],
+                attendees: [
+                  getMockBookingAttendee({
+                    id: 1,
+                    name: "Seat 1",
+                    email: "seat1@test.com",
+                    locale: "en",
+                    timeZone: "America/Toronto",
+                    bookingSeat: {
+                      referenceUid: seatRefToCancel1,
+                      data: {},
+                    },
+                  }),
+                  getMockBookingAttendee({
+                    id: 2,
+                    name: "Seat 2",
+                    email: "seat2@test.com",
+                    locale: "en",
+                    timeZone: "America/Toronto",
+                    bookingSeat: {
+                      referenceUid: seatRefToCancel2,
+                      data: {},
+                    },
+                  }),
+                  getMockBookingAttendee({
+                    id: 3,
+                    name: "Seat 3",
+                    email: "seat3@test.com",
+                    locale: "en",
+                    timeZone: "America/Toronto",
+                    bookingSeat: {
+                      referenceUid: "booking-seat-3",
+                      data: {},
+                    },
+                  }),
+                ],
+              },
+            ],
+            organizer,
+          })
+        );
+
+        mockSuccessfulVideoMeetingCreation({
+          metadataLookupKey: "dailyvideo",
+          videoMeetingData: {
+            id: "MOCK_ID",
+            password: "MOCK_PASS",
+            url: `http://mock-dailyvideo.example.com/meeting-1`,
+          },
+        });
+
+        const mockCancelBookingData = {
+          uid: bookingUid,
+          seatReferenceUid: [seatRefToCancel1, seatRefToCancel2],
+          cancellationReason: "test cancellation reason",
+        };
+
+        await handleCancelBooking({
+          bookingData: mockCancelBookingData,
+          userId: organizer.id,
+        });
+
+        // Ensure that the booking is still accepted
+        const booking = await prismaMock.booking.findFirst({
+          where: {
+            id: bookingId,
+          },
+          select: {
+            status: true,
+          },
+        });
+        expect(booking?.status).toEqual(BookingStatus.ACCEPTED);
+
+        // Check that only one attendee remains
+        const attendees = await prismaMock.attendee.findMany({
+          where: {
+            bookingId,
+          },
+          select: {
+            id: true,
+            email: true,
+          },
+        });
+        expect(attendees).toHaveLength(1);
+        expect(attendees[0].id).toBe(3);
+        expect(attendees[0].email).toBe("seat3@test.com");
+
+        // Check that the booking seats were also removed
+        const bookingSeats = await prismaMock.bookingSeat.findMany({
+          where: {
+            bookingId,
+          },
+          select: {
+            referenceUid: true,
+          },
+        });
+        expect(bookingSeats).toHaveLength(1);
+        expect(bookingSeats[0].referenceUid).toBe("booking-seat-3");
+      });
     });
   });
 });
diff --git a/packages/prisma/zod-utils.ts b/packages/prisma/zod-utils.ts
index ea992435034080..c66d3341320101 100644
--- a/packages/prisma/zod-utils.ts
+++ b/packages/prisma/zod-utils.ts
@@ -275,7 +275,7 @@ export const bookingCancelSchema = z.object({
   // note(Lauris): cancelSubsequentBookings will cancel all bookings after one specified by id or uid.
   cancelSubsequentBookings: z.boolean().optional(),
   cancellationReason: z.string().optional(),
-  seatReferenceUid: z.string().optional(),
+  seatReferenceUid: z.union([z.string(), z.array(z.string())]).optional(),
   cancelledBy: z.string().email({ message: "Invalid email" }).optional(),
   internalNote: z
     .object({
@@ -288,7 +288,7 @@ export const bookingCancelSchema = z.object({
 });
 
 export const bookingCancelAttendeeSeatSchema = z.object({
-  seatReferenceUid: z.string(),
+  seatReferenceUid: z.string().or(z.array(z.string())),
 });
 
 export const bookingCancelInput = bookingCancelSchema.refine(
diff --git a/packages/trpc/server/routers/viewer/bookings/get.handler.ts b/packages/trpc/server/routers/viewer/bookings/get.handler.ts
index 9aea7ee396099d..672c46990cdda8 100644
--- a/packages/trpc/server/routers/viewer/bookings/get.handler.ts
+++ b/packages/trpc/server/routers/viewer/bookings/get.handler.ts
@@ -502,6 +502,12 @@ export async function getBookings({
                 "EventType.hideOrganizerEmail",
                 "EventType.disableCancelling",
                 "EventType.disableRescheduling",
+                jsonObjectFrom(
+                  eb
+                    .selectFrom("EventType as ParentEventType")
+                    .select(["ParentEventType.id", "ParentEventType.teamId"])
+                    .whereRef("ParentEventType.id", "=", "EventType.parentId")
+                ).as("parent"),
                 eb
                   .cast<SchedulingType | null>(
                     eb
@@ -576,8 +582,18 @@ export async function getBookings({
                 jsonObjectFrom(
                   eb
                     .selectFrom("Attendee")
-                    .select(["Attendee.email"])
+                    .select(["Attendee.email", "Attendee.name"])
                     .whereRef("BookingSeat.attendeeId", "=", "Attendee.id")
+                    .where((qb) => {
+                      const isOwner = eb.exists(
+                        eb
+                          .selectFrom("Booking")
+                          .select("Booking.id")
+                          .whereRef("Booking.id", "=", "BookingSeat.bookingId")
+                          .where("Booking.userId", "=", user.id)
+                      );
+                      return eb.or([isOwner, qb("Attendee.email", "=", user.email)]);
+                    })
                 ).as("attendee"),
               ])
               .whereRef("BookingSeat.bookingId", "=", "Booking.id")
diff --git a/packages/trpc/server/routers/viewer/me/get.handler.ts b/packages/trpc/server/routers/viewer/me/get.handler.ts
index b25f9228a76924..3298c6b79b7734 100644
--- a/packages/trpc/server/routers/viewer/me/get.handler.ts
+++ b/packages/trpc/server/routers/viewer/me/get.handler.ts
@@ -106,6 +106,21 @@ export const getHandler = async ({ ctx, input }: MeOptions) => {
       },
     })) !== null;
 
+  const teamsWhereUserIsAdminOrOwner = await prisma.membership.findMany({
+    where: {
+      userId: user.id,
+      accepted: true,
+      role: { in: [MembershipRole.ADMIN, MembershipRole.OWNER] },
+      team: {
+        isOrganization: false,
+      },
+    },
+    select: {
+      id: true,
+      teamId: true,
+    },
+  });
+
   return {
     id: user.id,
     name: user.name,
@@ -145,5 +160,6 @@ export const getHandler = async ({ ctx, input }: MeOptions) => {
     isPremium: userMetadataPrased?.isPremium,
     ...(passwordAdded ? { passwordAdded } : {}),
     isTeamAdminOrOwner,
+    teamsWhereUserIsAdminOrOwner,
   };
 };