diff --git a/apps/web/app/(use-page-wrapper)/settings/(admin-layout)/admin/booking-reports/page.tsx b/apps/web/app/(use-page-wrapper)/settings/(admin-layout)/admin/booking-reports/page.tsx
new file mode 100644
index 00000000000000..a681fce0050f77
--- /dev/null
+++ b/apps/web/app/(use-page-wrapper)/settings/(admin-layout)/admin/booking-reports/page.tsx
@@ -0,0 +1,26 @@
+import { _generateMetadata } from "app/_utils";
+import { getTranslate } from "app/_utils";
+
+import SettingsHeader from "@calcom/features/settings/appDir/SettingsHeader";
+
+import BookingReportsView from "~/settings/admin/booking-reports-view";
+
+export const generateMetadata = async () =>
+  await _generateMetadata(
+    (t) => t("booking_reports"),
+    (t) => t("admin_booking_reports_description"),
+    undefined,
+    undefined,
+    "/settings/admin/booking-reports"
+  );
+
+const Page = async () => {
+  const t = await getTranslate();
+  return (
+    <SettingsHeader title={t("booking_reports")} description={t("admin_booking_reports_description")}>
+      <BookingReportsView />
+    </SettingsHeader>
+  );
+};
+
+export default Page;
diff --git a/apps/web/app/(use-page-wrapper)/settings/(settings-layout)/SettingsLayoutAppDirClient.tsx b/apps/web/app/(use-page-wrapper)/settings/(settings-layout)/SettingsLayoutAppDirClient.tsx
index 43190417291565..354a1448f30887 100644
--- a/apps/web/app/(use-page-wrapper)/settings/(settings-layout)/SettingsLayoutAppDirClient.tsx
+++ b/apps/web/app/(use-page-wrapper)/settings/(settings-layout)/SettingsLayoutAppDirClient.tsx
@@ -142,6 +142,7 @@ const getTabs = (orgBranding: OrganizationBranding | null) => {
         { name: "apps", href: "/settings/admin/apps/calendar" },
         { name: "users", href: "/settings/admin/users" },
         { name: "organizations", href: "/settings/admin/organizations" },
+        { name: "booking_reports", href: "/settings/admin/booking-reports" },
         { name: "lockedSMS", href: "/settings/admin/lockedSMS" },
         { name: "oAuth", href: "/settings/admin/oAuth" },
         { name: "Workspace Platforms", href: "/settings/admin/workspace-platforms" },
diff --git a/apps/web/modules/settings/admin/booking-reports-view.tsx b/apps/web/modules/settings/admin/booking-reports-view.tsx
new file mode 100644
index 00000000000000..f4b5bedc8e594d
--- /dev/null
+++ b/apps/web/modules/settings/admin/booking-reports-view.tsx
@@ -0,0 +1,433 @@
+"use client";
+
+import { keepPreviousData } from "@tanstack/react-query";
+import { getCoreRowModel, getSortedRowModel, useReactTable, type ColumnDef } from "@tanstack/react-table";
+import { useMemo, useState } from "react";
+
+import {
+  DataTableWrapper,
+  DataTableToolbar,
+  DataTableFilters,
+  ColumnFilterType,
+  useDataTable,
+  useColumnFilters,
+  convertFacetedValuesToMap,
+  DataTableSelectionBar,
+  DataTableProvider,
+} from "@calcom/features/data-table";
+import { useSegments } from "@calcom/features/data-table/hooks/useSegments";
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { trpc } from "@calcom/trpc";
+import type { RouterOutputs } from "@calcom/trpc/react";
+import { Badge } from "@calcom/ui/components/badge";
+import { Button } from "@calcom/ui/components/button";
+import { ButtonGroup } from "@calcom/ui/components/buttonGroup";
+import { ConfirmationDialogContent, Dialog } from "@calcom/ui/components/dialog";
+import {
+  Dropdown,
+  DropdownItem,
+  DropdownMenuTrigger,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuPortal,
+} from "@calcom/ui/components/dropdown";
+import { Checkbox } from "@calcom/ui/components/form";
+import { showToast } from "@calcom/ui/components/toast";
+import { Tooltip } from "@calcom/ui/components/tooltip";
+
+import { AddToBlocklistModal } from "./components/add-to-blocklist-modal";
+import { BookingReportDetailsSheet } from "./components/booking-report-details-sheet";
+import { BulkAddToBlocklist } from "./components/bulk-add-to-blocklist";
+
+type BookingReport = RouterOutputs["viewer"]["admin"]["listBookingReports"]["rows"][number];
+
+function BookingReportsTable() {
+  const { t } = useLocale();
+  const { limit, offset, searchTerm } = useDataTable();
+  const columnFilters = useColumnFilters();
+
+  const [selectedReport, setSelectedReport] = useState<BookingReport | null>(null);
+  const [showWatchlistModal, setShowWatchlistModal] = useState(false);
+  const [showDetailsSheet, setShowDetailsSheet] = useState(false);
+  const [showDeleteDialog, setShowDeleteDialog] = useState(false);
+  const [rowSelection, setRowSelection] = useState({});
+
+  const filters = useMemo(() => {
+    const statusFilter = columnFilters.find((f) => f.id === "status");
+
+    let hasWatchlistValue: boolean | undefined = undefined;
+
+    if (statusFilter && statusFilter.value.type === ColumnFilterType.MULTI_SELECT) {
+      const filterValues = statusFilter.value.data;
+      if (Array.isArray(filterValues) && filterValues.length > 0) {
+        if (filterValues.length === 2 || filterValues.length === 0) {
+          hasWatchlistValue = undefined;
+        } else {
+          hasWatchlistValue = filterValues[0] === "blocked";
+        }
+      }
+    }
+
+    return {
+      hasWatchlist: hasWatchlistValue,
+    };
+  }, [columnFilters]);
+
+  const { data, isPending } = trpc.viewer.admin.listBookingReports.useQuery(
+    {
+      limit,
+      offset,
+      searchTerm,
+      filters,
+    },
+    {
+      placeholderData: keepPreviousData,
+    }
+  );
+
+  const utils = trpc.useUtils();
+
+  const deleteReportMutation = trpc.viewer.admin.deleteBookingReport.useMutation({
+    onSuccess: async () => {
+      await utils.viewer.admin.listBookingReports.invalidate();
+      showToast(t("booking_report_deleted"), "success");
+      setShowDeleteDialog(false);
+      setSelectedReport(null);
+    },
+    onError: (error) => {
+      showToast(error.message, "error");
+    },
+  });
+
+  const totalRowCount = data?.meta?.totalRowCount ?? 0;
+  const flatData = useMemo<BookingReport[]>(() => data?.rows ?? [], [data]);
+
+  const columns = useMemo<ColumnDef<BookingReport>[]>(
+    () => [
+      {
+        id: "select",
+        enableHiding: false,
+        enableSorting: false,
+        enableResizing: false,
+        size: 30,
+        header: ({ table }) => (
+          <Checkbox
+            checked={table.getIsAllPageRowsSelected()}
+            onCheckedChange={(value) => table.toggleAllPageRowsSelected(!!value)}
+            aria-label="Select all"
+          />
+        ),
+        cell: ({ row }) => (
+          <Checkbox
+            checked={row.getIsSelected()}
+            onCheckedChange={(value) => row.toggleSelected(!!value)}
+            aria-label="Select row"
+            className="translate-y-[2px]"
+          />
+        ),
+      },
+      {
+        id: "bookerEmail",
+        header: t("booker_email"),
+        accessorKey: "bookerEmail",
+        enableHiding: false,
+        cell: ({ row }) => <span className="text-emphasis font-medium">{row.original.bookerEmail}</span>,
+      },
+      {
+        id: "reportedBy",
+        header: t("reported_by"),
+        accessorFn: (row) => row.reporter?.email ?? "-",
+        size: 180,
+        cell: ({ row }) => <span className="text-default">{row.original.reporter?.email ?? "-"}</span>,
+      },
+      {
+        id: "reason",
+        header: t("reason"),
+        accessorKey: "reason",
+        size: 90,
+        cell: ({ row }) => {
+          const reasonColors: Record<string, "red" | "orange" | "gray"> = {
+            SPAM: "red",
+            DONT_KNOW_PERSON: "orange",
+            OTHER: "gray",
+          };
+          const reason = t(row.original.reason.toLowerCase());
+          return (
+            <Badge variant={reasonColors[row.original.reason] || "gray"}>
+              {reason.charAt(0).toUpperCase() + reason.slice(1)}
+            </Badge>
+          );
+        },
+      },
+      {
+        id: "status",
+        header: t("status"),
+        accessorFn: (row) => (row.watchlistId ? "blocked" : "pending"),
+        size: 120,
+        cell: ({ row }) => (
+          <Badge variant={row.original.watchlistId ? "blue" : "orange"}>
+            {row.original.watchlistId ? t("blocked") : t("pending")}
+          </Badge>
+        ),
+      },
+      {
+        id: "actions",
+        header: "",
+        size: 90,
+        enableHiding: false,
+        enableSorting: false,
+        enableResizing: false,
+        cell: ({ row }) => {
+          const report = row.original;
+          return (
+            <div className="flex items-center justify-end">
+              <ButtonGroup combined containerProps={{ className: "border-default hidden md:flex" }}>
+                <Tooltip content={t("view_booking_page")}>
+                  <Button
+                    target="_blank"
+                    href={`/booking/${report.booking.uid}`}
+                    color="secondary"
+                    variant="icon"
+                    StartIcon="external-link"
+                  />
+                </Tooltip>
+                <Dropdown>
+                  <DropdownMenuTrigger asChild>
+                    <Button
+                      className="radix-state-open:rounded-r-md"
+                      color="secondary"
+                      variant="icon"
+                      StartIcon="ellipsis"
+                    />
+                  </DropdownMenuTrigger>
+                  <DropdownMenuPortal>
+                    <DropdownMenuContent>
+                      <DropdownMenuItem>
+                        <DropdownItem
+                          type="button"
+                          onClick={() => {
+                            setSelectedReport(report);
+                            setShowDetailsSheet(true);
+                          }}
+                          StartIcon="eye">
+                          {t("view")}
+                        </DropdownItem>
+                      </DropdownMenuItem>
+                      {!report.watchlistId && (
+                        <DropdownMenuItem>
+                          <DropdownItem
+                            type="button"
+                            onClick={() => {
+                              setSelectedReport(report);
+                              setShowWatchlistModal(true);
+                            }}
+                            StartIcon="shield-check">
+                            {t("add_to_blocklist")}
+                          </DropdownItem>
+                        </DropdownMenuItem>
+                      )}
+                      <DropdownMenuItem>
+                        <DropdownItem
+                          type="button"
+                          onClick={() => {
+                            setSelectedReport(report);
+                            setShowDeleteDialog(true);
+                          }}
+                          color="destructive"
+                          StartIcon="trash">
+                          {t("delete")}
+                        </DropdownItem>
+                      </DropdownMenuItem>
+                    </DropdownMenuContent>
+                  </DropdownMenuPortal>
+                </Dropdown>
+              </ButtonGroup>
+              <div className="flex md:hidden">
+                <Dropdown>
+                  <DropdownMenuTrigger asChild>
+                    <Button type="button" variant="icon" color="minimal" StartIcon="ellipsis" />
+                  </DropdownMenuTrigger>
+                  <DropdownMenuPortal>
+                    <DropdownMenuContent>
+                      <DropdownMenuItem className="outline-none">
+                        <DropdownItem
+                          href={`/booking/${report.booking.uid}`}
+                          target="_blank"
+                          type="button"
+                          StartIcon="external-link">
+                          {t("view_booking_page")}
+                        </DropdownItem>
+                      </DropdownMenuItem>
+                      <DropdownMenuItem>
+                        <DropdownItem
+                          type="button"
+                          onClick={() => {
+                            setSelectedReport(report);
+                            setShowDetailsSheet(true);
+                          }}
+                          StartIcon="eye">
+                          {t("view")}
+                        </DropdownItem>
+                      </DropdownMenuItem>
+                      {!report.watchlistId && (
+                        <DropdownMenuItem>
+                          <DropdownItem
+                            type="button"
+                            onClick={() => {
+                              setSelectedReport(report);
+                              setShowWatchlistModal(true);
+                            }}
+                            StartIcon="shield-check">
+                            {t("add_to_blocklist")}
+                          </DropdownItem>
+                        </DropdownMenuItem>
+                      )}
+                      <DropdownMenuItem>
+                        <DropdownItem
+                          type="button"
+                          color="destructive"
+                          onClick={() => {
+                            setSelectedReport(report);
+                            setShowDeleteDialog(true);
+                          }}
+                          StartIcon="trash">
+                          {t("delete")}
+                        </DropdownItem>
+                      </DropdownMenuItem>
+                    </DropdownMenuContent>
+                  </DropdownMenuPortal>
+                </Dropdown>
+              </div>
+            </div>
+          );
+        },
+      },
+    ],
+    [t, setSelectedReport, setShowDetailsSheet]
+  );
+
+  const table = useReactTable({
+    data: flatData,
+    columns,
+    getCoreRowModel: getCoreRowModel(),
+    getSortedRowModel: getSortedRowModel(),
+    manualPagination: true,
+    getRowId: (row) => row.id,
+    onRowSelectionChange: setRowSelection,
+    state: {
+      rowSelection,
+    },
+    enableRowSelection: true,
+    getFacetedUniqueValues: (_, columnId) => () => {
+      switch (columnId) {
+        case "status":
+          return convertFacetedValuesToMap([
+            { label: t("pending"), value: "pending" },
+            { label: t("blocked"), value: "blocked" },
+          ]);
+        case "reason":
+          return convertFacetedValuesToMap([
+            { label: t("spam"), value: "SPAM" },
+            { label: t("dont_know_person"), value: "DONT_KNOW_PERSON" },
+            { label: t("other"), value: "OTHER" },
+          ]);
+        default:
+          return new Map();
+      }
+    },
+  });
+
+  const numberOfSelectedRows = table.getFilteredSelectedRowModel().rows.length;
+
+  return (
+    <>
+      <DataTableWrapper
+        table={table}
+        isPending={isPending}
+        paginationMode="standard"
+        totalRowCount={totalRowCount}
+        ToolbarLeft={
+          <>
+            <DataTableToolbar.SearchBar />
+            <DataTableFilters.FilterBar table={table} />
+          </>
+        }
+        ToolbarRight={
+          <>
+            <DataTableFilters.ClearFiltersButton />
+          </>
+        }>
+        {numberOfSelectedRows > 0 && (
+          <DataTableSelectionBar.Root className="!bottom-16 justify-center md:w-max">
+            <p className="text-brand-subtle px-2 text-center text-xs leading-none sm:text-sm sm:font-medium">
+              {t("number_selected", { count: numberOfSelectedRows })}
+            </p>
+            <BulkAddToBlocklist
+              reports={table.getSelectedRowModel().flatRows.map((row) => row.original)}
+              onSuccess={() => table.toggleAllPageRowsSelected(false)}
+            />
+          </DataTableSelectionBar.Root>
+        )}
+      </DataTableWrapper>
+
+      {selectedReport && showDetailsSheet && (
+        <BookingReportDetailsSheet
+          open={showDetailsSheet}
+          onClose={() => {
+            setShowDetailsSheet(false);
+            setSelectedReport(null);
+          }}
+          report={selectedReport}
+          onAddToBlocklist={
+            !selectedReport.watchlistId
+              ? () => {
+                  setShowDetailsSheet(false);
+                  setShowWatchlistModal(true);
+                }
+              : undefined
+          }
+        />
+      )}
+
+      {selectedReport && showWatchlistModal && (
+        <AddToBlocklistModal
+          open={showWatchlistModal}
+          onClose={() => {
+            setShowWatchlistModal(false);
+            setSelectedReport(null);
+          }}
+          report={selectedReport}
+        />
+      )}
+
+      {selectedReport && showDeleteDialog && (
+        <Dialog
+          open={showDeleteDialog}
+          onOpenChange={(open) => {
+            if (!open) {
+              setShowDeleteDialog(false);
+              setSelectedReport(null);
+            }
+          }}>
+          <ConfirmationDialogContent
+            variety="danger"
+            title={t("delete_booking_report")}
+            confirmBtnText={t("delete")}
+            onConfirm={() => {
+              deleteReportMutation.mutate({ reportId: selectedReport.id });
+            }}>
+            {t("delete_booking_report_confirmation")}
+          </ConfirmationDialogContent>
+        </Dialog>
+      )}
+    </>
+  );
+}
+
+export default function BookingReportsView() {
+  return (
+    <DataTableProvider useSegments={useSegments} defaultPageSize={25}>
+      <BookingReportsTable />
+    </DataTableProvider>
+  );
+}
diff --git a/apps/web/modules/settings/admin/components/add-to-blocklist-modal.tsx b/apps/web/modules/settings/admin/components/add-to-blocklist-modal.tsx
new file mode 100644
index 00000000000000..6b0682a9a5a65e
--- /dev/null
+++ b/apps/web/modules/settings/admin/components/add-to-blocklist-modal.tsx
@@ -0,0 +1,146 @@
+"use client";
+
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useForm } from "react-hook-form";
+import { z } from "zod";
+
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { WatchlistType } from "@calcom/prisma/enums";
+import { trpc } from "@calcom/trpc";
+import type { RouterOutputs } from "@calcom/trpc/react";
+import { Button } from "@calcom/ui/components/button";
+import { Dialog, DialogContent, DialogHeader, DialogFooter } from "@calcom/ui/components/dialog";
+import { Form, Label, Select, TextAreaField } from "@calcom/ui/components/form";
+import { showToast } from "@calcom/ui/components/toast";
+
+type BookingReport = RouterOutputs["viewer"]["admin"]["listBookingReports"]["rows"][number];
+
+interface AddToWatchlistModalProps {
+  open: boolean;
+  onClose: () => void;
+  report?: BookingReport;
+  reports?: BookingReport[];
+}
+
+const formSchema = z.object({
+  type: z.nativeEnum(WatchlistType),
+  description: z.string().optional(),
+});
+
+type FormValues = z.infer<typeof formSchema>;
+
+export function AddToBlocklistModal({ open, onClose, report, reports }: AddToWatchlistModalProps) {
+  const { t } = useLocale();
+  const utils = trpc.useUtils();
+
+  const form = useForm<FormValues>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+      type: WatchlistType.EMAIL,
+      description: "",
+    },
+  });
+
+  const isBulk = !!reports && reports.length > 0;
+  const firstReport = isBulk ? reports[0] : report;
+
+  if (!firstReport) {
+    return null;
+  }
+
+  const watchlistType = form.watch("type");
+
+  const addToWatchlistMutation = trpc.viewer.admin.addToWatchlist.useMutation({
+    onSuccess: () => {
+      showToast(t("successfully_added_to_blocklist"), "success");
+      utils.viewer.admin.listBookingReports.invalidate();
+      onClose();
+      form.reset();
+    },
+    onError: (error) => {
+      showToast(error.message, "error");
+    },
+  });
+
+  const onSubmit = (data: FormValues) => {
+    const reportIds = isBulk ? reports.map((r) => r.id) : [firstReport.id];
+
+    addToWatchlistMutation.mutate({
+      reportIds,
+      type: data.type,
+      description: data.description,
+    });
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
+      <DialogContent enableOverflow>
+        <DialogHeader
+          title={t("add_to_blocklist")}
+          subtitle={
+            isBulk
+              ? t("add_multiple_to_blocklist_subtitle", { count: reports.length })
+              : t("add_to_blocklist_subtitle", { email: firstReport.bookerEmail })
+          }
+        />
+
+        <Form form={form} handleSubmit={onSubmit}>
+          <div className="space-y-4">
+            <div>
+              <Label>{t("what_to_add")}</Label>
+              <Select
+                options={[
+                  {
+                    label: t("this_email_address"),
+                    value: WatchlistType.EMAIL,
+                    description: firstReport.bookerEmail,
+                  },
+                  {
+                    label: t("entire_domain"),
+                    value: WatchlistType.DOMAIN,
+                    description: `${t("all_emails_from")} @${firstReport.bookerEmail.split("@")[1]}`,
+                  },
+                ]}
+                value={
+                  watchlistType === WatchlistType.EMAIL
+                    ? {
+                        label: t("this_email_address"),
+                        value: WatchlistType.EMAIL,
+                        description: firstReport.bookerEmail,
+                      }
+                    : {
+                        label: t("entire_domain"),
+                        value: WatchlistType.DOMAIN,
+                        description: `${t("all_emails_from")} @${firstReport.bookerEmail.split("@")[1]}`,
+                      }
+                }
+                onChange={(option) => {
+                  if (option && "value" in option) {
+                    form.setValue("type", option.value as WatchlistType);
+                  }
+                }}
+              />
+            </div>
+
+            <div>
+              <TextAreaField
+                {...form.register("description")}
+                placeholder={t("add_internal_note_placeholder")}
+                rows={3}
+              />
+            </div>
+          </div>
+
+          <DialogFooter>
+            <Button type="button" color="minimal" onClick={onClose}>
+              {t("cancel")}
+            </Button>
+            <Button type="submit" loading={addToWatchlistMutation.isPending}>
+              {t("add_to_blocklist")}
+            </Button>
+          </DialogFooter>
+        </Form>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/web/modules/settings/admin/components/booking-report-details-sheet.tsx b/apps/web/modules/settings/admin/components/booking-report-details-sheet.tsx
new file mode 100644
index 00000000000000..b239f4c3767685
--- /dev/null
+++ b/apps/web/modules/settings/admin/components/booking-report-details-sheet.tsx
@@ -0,0 +1,154 @@
+"use client";
+
+import { format } from "date-fns";
+
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import type { RouterOutputs } from "@calcom/trpc/react";
+import { Badge } from "@calcom/ui/components/badge";
+import { Button } from "@calcom/ui/components/button";
+import { Sheet, SheetContent, SheetHeader, SheetBody } from "@calcom/ui/components/sheet";
+
+type BookingReport = RouterOutputs["viewer"]["admin"]["listBookingReports"]["rows"][number];
+
+interface BookingReportDetailsSheetProps {
+  open: boolean;
+  onClose: () => void;
+  report: BookingReport;
+  onAddToBlocklist?: () => void;
+}
+
+export function BookingReportDetailsSheet({
+  open,
+  onClose,
+  report,
+  onAddToBlocklist,
+}: BookingReportDetailsSheetProps) {
+  const { t } = useLocale();
+
+  const reasonColors: Record<string, "red" | "orange" | "gray"> = {
+    SPAM: "red",
+    DONT_KNOW_PERSON: "orange",
+    OTHER: "gray",
+  };
+
+  return (
+    <Sheet open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
+      <SheetContent>
+        <SheetHeader>
+          <div className="flex items-center justify-between">
+            <div>
+              <h2 className="text-emphasis text-base font-semibold">{report.bookerEmail}</h2>
+              <div className="mt-2 flex items-center gap-2">
+                <Badge variant={reasonColors[report.reason] || "gray"} className="text-xs">
+                  {t(report.reason.toLowerCase())}
+                </Badge>
+                {report.watchlistId && (
+                  <Badge variant="blue" className="text-xs">
+                    {t("in_blocklist")}
+                  </Badge>
+                )}
+                {report.cancelled && (
+                  <Badge variant="green" className="text-xs">
+                    {t("cancelled")}
+                  </Badge>
+                )}
+              </div>
+            </div>
+          </div>
+        </SheetHeader>
+
+        <SheetBody className="space-y-6">
+          <div className="space-y-4">
+            <h3 className="text-emphasis text-sm font-semibold">{t("booking_details")}</h3>
+            <div className="space-y-3">
+              <div className="flex flex-col">
+                <span className="text-subtle text-xs">{t("booker_email")}</span>
+                <span className="text-default text-sm">{report.bookerEmail}</span>
+              </div>
+              <div className="flex flex-col">
+                <span className="text-subtle text-xs">{t("booking_date")}</span>
+                <span className="text-default text-sm">
+                  {format(new Date(report.booking.startTime), "PPP p")}
+                </span>
+              </div>
+              <div className="flex flex-col">
+                <span className="text-subtle text-xs">{t("booking_title")}</span>
+                <span className="text-default text-sm">{report.booking.title || t("no_title")}</span>
+              </div>
+              <div className="flex flex-col">
+                <span className="text-subtle text-xs">{t("view_booking")}</span>
+                <a
+                  href={`/booking/${report.booking.uid}`}
+                  target="_blank"
+                  rel="noopener noreferrer"
+                  className="text-brand-default hover:text-brand-emphasis text-sm underline">
+                  /booking/{report.booking.uid}
+                </a>
+              </div>
+            </div>
+          </div>
+
+          <div className="space-y-4">
+            <h3 className="text-emphasis text-sm font-semibold">{t("report_details")}</h3>
+            <div className="space-y-3">
+              <div className="flex flex-col">
+                <span className="text-subtle text-xs">{t("reported_by")}</span>
+                <span className="text-default text-sm">
+                  {report.reporter?.name || ""} ({report.reporter?.email ?? "-"})
+                </span>
+              </div>
+              <div className="flex flex-col">
+                <span className="text-subtle text-xs">{t("reported_at")}</span>
+                <span className="text-default text-sm">{format(new Date(report.createdAt), "PPP p")}</span>
+              </div>
+              <div className="flex flex-col">
+                <span className="text-subtle text-xs">{t("reason")}</span>
+                <span className="text-default text-sm">{t(report.reason.toLowerCase())}</span>
+              </div>
+              {report.description && (
+                <div className="flex flex-col">
+                  <span className="text-subtle text-xs">{t("description")}</span>
+                  <span className="text-default text-sm">{report.description}</span>
+                </div>
+              )}
+            </div>
+          </div>
+
+          {report.watchlistId && report.watchlist && (
+            <div className="space-y-4">
+              <h3 className="text-emphasis text-sm font-semibold">{t("blocklist_info")}</h3>
+              <div className="space-y-3">
+                <div className="flex flex-col">
+                  <span className="text-subtle text-xs">{t("blocklist_type")}</span>
+                  <span className="text-default text-sm">{report.watchlist.type}</span>
+                </div>
+                <div className="flex flex-col">
+                  <span className="text-subtle text-xs">{t("blocklist_value")}</span>
+                  <span className="text-default text-sm">{report.watchlist.value}</span>
+                </div>
+                <div className="flex flex-col">
+                  <span className="text-subtle text-xs">{t("blocklist_action")}</span>
+                  <span className="text-default text-sm">{report.watchlist.action}</span>
+                </div>
+                {report.watchlist.description && (
+                  <div className="flex flex-col">
+                    <span className="text-subtle text-xs">{t("blocklist_description")}</span>
+                    <span className="text-default text-sm">{report.watchlist.description}</span>
+                  </div>
+                )}
+              </div>
+            </div>
+          )}
+
+          {!report.watchlistId && onAddToBlocklist && (
+            <div className="pt-4">
+              <Button onClick={onAddToBlocklist} color="primary" className="w-full justify-center">
+                {t("add_to_blocklist")}
+              </Button>
+            </div>
+          )}
+        </SheetBody>
+      </SheetContent>
+    </Sheet>
+  );
+}
diff --git a/apps/web/modules/settings/admin/components/bulk-add-to-blocklist.tsx b/apps/web/modules/settings/admin/components/bulk-add-to-blocklist.tsx
new file mode 100644
index 00000000000000..bc424e5a9afbbd
--- /dev/null
+++ b/apps/web/modules/settings/admin/components/bulk-add-to-blocklist.tsx
@@ -0,0 +1,49 @@
+"use client";
+
+import { useState } from "react";
+
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import type { RouterOutputs } from "@calcom/trpc/react";
+import { Button } from "@calcom/ui/components/button";
+
+import { AddToBlocklistModal } from "./add-to-blocklist-modal";
+
+type BookingReport = RouterOutputs["viewer"]["admin"]["listBookingReports"]["rows"][number];
+
+interface BulkAddToBlocklistProps {
+  reports: BookingReport[];
+  onSuccess: () => void;
+}
+
+export function BulkAddToBlocklist({ reports, onSuccess }: BulkAddToBlocklistProps) {
+  const { t } = useLocale();
+  const [showModal, setShowModal] = useState(false);
+
+  const reportsToAdd = reports.filter((report) => !report.watchlistId);
+
+  const handleModalClose = () => {
+    setShowModal(false);
+    onSuccess();
+  };
+
+  if (reportsToAdd.length === 0) {
+    return null;
+  }
+
+  return (
+    <>
+      <Button
+        color="secondary"
+        StartIcon="shield-check"
+        onClick={() => {
+          setShowModal(true);
+        }}>
+        {t("add_to_blocklist")}
+      </Button>
+
+      {showModal && (
+        <AddToBlocklistModal open={showModal} onClose={handleModalClose} reports={reportsToAdd} />
+      )}
+    </>
+  );
+}
diff --git a/apps/web/public/static/locales/en/common.json b/apps/web/public/static/locales/en/common.json
index c68527b661e3fb..2d92f86f8fd582 100644
--- a/apps/web/public/static/locales/en/common.json
+++ b/apps/web/public/static/locales/en/common.json
@@ -1707,6 +1707,11 @@
   "impersonation": "Impersonation",
   "impersonation_description": "Settings to manage user impersonation",
   "recent_impersonations": "Recent Impersonations",
+  "booking_reports": "Booking Reports",
+  "admin_booking_reports_description": "View and manage booking reports",
+  "booker_email": "Booker Email",
+  "reported_by": "Reported By",
+  "in_blocklist": "In Blocklist",
   "quick_impersonate": "Quick Impersonate",
   "no_recent_impersonations": "No recent impersonations",
   "users": "Users",
@@ -3839,5 +3844,21 @@
   "reason_for_adding_to_blocklist": "Reason for adding to blocklist",
   "what_would_you_like_to_block": "What would you like to block?",
   "domain_name": "Domain Name",
+  "add_to_blocklist": "Add to Blocklist",
+  "add_to_blocklist_subtitle": "Block {{email}} from booking with your organization",
+  "add_multiple_to_blocklist_subtitle": "Add {{count}} bookers to the blocklist",
+  "what_to_add": "What to add",
+  "this_email_address": "This email address",
+  "entire_domain": "Entire domain",
+  "all_emails_from": "All emails from",
+  "add_internal_note_placeholder": "Add an optional internal note about why this is being blocked",
+  "successfully_added_to_blocklist": "Successfully added to blocklist",
+  "report_details": "Report Details",
+  "blocklist_info": "Blocklist Info",
+  "blocklist_type": "Blocklist Type",
+  "blocklist_value": "Blocklist Value",
+  "blocklist_action": "Blocklist Action",
+  "blocklist_description": "Blocklist Description",
+  "blocked": "Blocked",
   "ADD_NEW_STRINGS_ABOVE_THIS_LINE_TO_PREVENT_MERGE_CONFLICTS": "↑↑↑↑↑↑↑↑↑↑↑↑↑ Add your new strings above here ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"
 }
diff --git a/packages/lib/server/repository/bookingReport.interface.ts b/packages/lib/server/repository/bookingReport.interface.ts
index 9d74cf9174b8a6..c3ab79f99e5303 100644
--- a/packages/lib/server/repository/bookingReport.interface.ts
+++ b/packages/lib/server/repository/bookingReport.interface.ts
@@ -1,4 +1,4 @@
-import type { BookingReportReason } from "@calcom/prisma/enums";
+import type { BookingReportReason, WatchlistType, WatchlistAction } from "@calcom/prisma/enums";
 
 export interface CreateBookingReportInput {
   bookingUid: string;
@@ -18,8 +18,68 @@ export interface BookingReportSummary {
   createdAt: Date;
 }
 
+export interface BookingReportWithDetails {
+  id: string;
+  bookingUid: string;
+  bookerEmail: string;
+  reportedById: number | null;
+  reason: BookingReportReason;
+  description: string | null;
+  cancelled: boolean;
+  createdAt: Date;
+  watchlistId: string | null;
+
+  reporter?: {
+    id: number;
+    name: string | null;
+    email: string;
+  } | null;
+  booking: {
+    id: number;
+    startTime: Date;
+    endTime: Date;
+    title: string | null;
+    uid: string;
+  };
+  watchlist: {
+    id: string;
+    type: WatchlistType;
+    value: string;
+    action: WatchlistAction;
+    description: string | null;
+  } | null;
+}
+
+export interface ListBookingReportsFilters {
+  reason?: BookingReportReason[];
+  cancelled?: boolean;
+  hasWatchlist?: boolean;
+  dateRange?: {
+    from?: Date;
+    to?: Date;
+  };
+}
+
 export interface IBookingReportRepository {
   createReport(input: CreateBookingReportInput): Promise<{ id: string }>;
 
-  findAllReportedBookings(params: { skip?: number; take?: number }): Promise<BookingReportSummary[]>;
+  findAllReportedBookings(params: {
+    organizationId?: number;
+    skip?: number;
+    take?: number;
+    searchTerm?: string;
+    filters?: ListBookingReportsFilters;
+  }): Promise<{
+    rows: BookingReportWithDetails[];
+    meta: { totalRowCount: number };
+  }>;
+
+  findReportsByIds(params: {
+    reportIds: string[];
+    organizationId?: number;
+  }): Promise<BookingReportWithDetails[]>;
+
+  linkWatchlistToReport(params: { reportId: string; watchlistId: string }): Promise<void>;
+
+  deleteReport(params: { reportId: string; organizationId?: number }): Promise<void>;
 }
diff --git a/packages/lib/server/repository/bookingReport.test.ts b/packages/lib/server/repository/bookingReport.test.ts
index d185c8606ffc98..61c4f6b8de4cdd 100644
--- a/packages/lib/server/repository/bookingReport.test.ts
+++ b/packages/lib/server/repository/bookingReport.test.ts
@@ -19,6 +19,9 @@ describe("PrismaBookingReportRepository", () => {
       findUnique: vi.fn(),
       findMany: vi.fn(),
       findFirst: vi.fn(),
+      count: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
     },
   } as unknown as PrismaClient;
 
@@ -94,37 +97,53 @@ describe("PrismaBookingReportRepository", () => {
       const mockReports = [
         {
           id: "report-1",
+          bookingUid: "uid-1",
+          bookerEmail: "a@example.com",
           reportedById: 1,
           reason: BookingReportReason.SPAM,
           description: "Spam",
+          cancelled: false,
           createdAt: new Date("2025-01-01T10:00:00Z"),
+          watchlistId: null,
+          reportedBy: { id: 1, name: "Admin", email: "admin@example.com" },
+          booking: { id: 1, startTime: new Date(), endTime: new Date(), title: "t", uid: "uid-1" },
+          watchlist: null,
         },
         {
           id: "report-2",
+          bookingUid: "uid-2",
+          bookerEmail: "b@example.com",
           reportedById: 2,
           reason: BookingReportReason.DONT_KNOW_PERSON,
           description: null,
+          cancelled: true,
           createdAt: new Date("2025-01-01T11:00:00Z"),
+          watchlistId: null,
+          reportedBy: { id: 2, name: "User", email: "user@example.com" },
+          booking: { id: 2, startTime: new Date(), endTime: new Date(), title: "t2", uid: "uid-2" },
+          watchlist: null,
         },
       ];
 
+      mockPrisma.bookingReport.count.mockResolvedValue(mockReports.length);
       mockPrisma.bookingReport.findMany.mockResolvedValue(mockReports);
 
-      const result = await repository.findAllReportedBookings({ skip: 0, take: 10 });
-
-      expect(result).toEqual(mockReports);
-      expect(mockPrisma.bookingReport.findMany).toHaveBeenCalledWith({
-        skip: 0,
-        take: 10,
-        select: {
-          id: true,
-          reportedById: true,
-          reason: true,
-          description: true,
-          createdAt: true,
-        },
-        orderBy: { createdAt: "desc" },
-      });
+      const result = await repository.findAllReportedBookings({ organizationId: 10, skip: 0, take: 10 });
+
+      expect(result.meta.totalRowCount).toBe(2);
+      expect(result.rows).toEqual(
+        mockReports.map((r) => ({ ...r, reporter: r.reportedBy }))
+      );
+      expect(mockPrisma.bookingReport.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({ organizationId: 10 }),
+          skip: 0,
+          take: 10,
+        })
+      );
+      expect(mockPrisma.bookingReport.count).toHaveBeenCalledWith(
+        expect.objectContaining({ where: expect.objectContaining({ organizationId: 10 }) })
+      );
     });
   });
 });
diff --git a/packages/lib/server/repository/bookingReport.ts b/packages/lib/server/repository/bookingReport.ts
index f9ef5c9c2efe37..cf03a5d20fbe3f 100644
--- a/packages/lib/server/repository/bookingReport.ts
+++ b/packages/lib/server/repository/bookingReport.ts
@@ -1,9 +1,11 @@
 import type { PrismaClient } from "@calcom/prisma";
+import type { Prisma } from "@calcom/prisma/client";
 
 import type {
   IBookingReportRepository,
   CreateBookingReportInput,
-  BookingReportSummary,
+  BookingReportWithDetails,
+  ListBookingReportsFilters,
 } from "./bookingReport.interface";
 
 export class PrismaBookingReportRepository implements IBookingReportRepository {
@@ -25,19 +27,189 @@ export class PrismaBookingReportRepository implements IBookingReportRepository {
     return report;
   }
 
-  async findAllReportedBookings(params: { skip?: number; take?: number }): Promise<BookingReportSummary[]> {
+  async findAllReportedBookings(params: {
+    organizationId?: number;
+    skip?: number;
+    take?: number;
+    searchTerm?: string;
+    filters?: ListBookingReportsFilters;
+  }): Promise<{
+    rows: BookingReportWithDetails[];
+    meta: { totalRowCount: number };
+  }> {
+    const where: Prisma.BookingReportWhereInput = {};
+
+    if (params.organizationId !== undefined) {
+      where.organizationId = params.organizationId;
+    }
+
+    if (params.searchTerm) {
+      where.OR = [
+        { bookerEmail: { contains: params.searchTerm, mode: "insensitive" } },
+        { description: { contains: params.searchTerm, mode: "insensitive" } },
+        {
+          reportedBy: {
+            OR: [
+              { name: { contains: params.searchTerm, mode: "insensitive" } },
+              { email: { contains: params.searchTerm, mode: "insensitive" } },
+            ],
+          },
+        },
+      ];
+    }
+
+    if (params.filters) {
+      if (params.filters.reason && params.filters.reason.length > 0) {
+        where.reason = { in: params.filters.reason };
+      }
+      if (params.filters.cancelled !== undefined) {
+        where.cancelled = params.filters.cancelled;
+      }
+      if (params.filters.hasWatchlist !== undefined) {
+        where.watchlistId = params.filters.hasWatchlist ? { not: null } : null;
+      }
+      if (params.filters.dateRange) {
+        where.createdAt = {};
+        if (params.filters.dateRange.from) {
+          where.createdAt.gte = params.filters.dateRange.from;
+        }
+        if (params.filters.dateRange.to) {
+          where.createdAt.lte = params.filters.dateRange.to;
+        }
+      }
+    }
+
+    const [totalCount, reports] = await Promise.all([
+      this.prismaClient.bookingReport.count({ where }),
+      this.prismaClient.bookingReport.findMany({
+        where,
+        skip: params.skip,
+        take: params.take,
+        select: {
+          id: true,
+          bookingUid: true,
+          bookerEmail: true,
+          reportedById: true,
+          reason: true,
+          description: true,
+          cancelled: true,
+          createdAt: true,
+          watchlistId: true,
+          reportedBy: {
+            select: {
+              id: true,
+              name: true,
+              email: true,
+            },
+          },
+          booking: {
+            select: {
+              id: true,
+              startTime: true,
+              endTime: true,
+              title: true,
+              uid: true,
+            },
+          },
+          watchlist: {
+            select: {
+              id: true,
+              type: true,
+              value: true,
+              action: true,
+              description: true,
+            },
+          },
+        },
+        orderBy: [{ watchlistId: { sort: "asc", nulls: "first" } }, { createdAt: "desc" }],
+      }),
+    ]);
+
+    return {
+      rows: reports.map((report) => ({
+        ...report,
+        reporter: report.reportedBy,
+      })),
+      meta: { totalRowCount: totalCount },
+    };
+  }
+
+  async linkWatchlistToReport(params: { reportId: string; watchlistId: string }): Promise<void> {
+    await this.prismaClient.bookingReport.update({
+      where: { id: params.reportId },
+      data: { watchlistId: params.watchlistId },
+    });
+  }
+
+  async findReportsByIds(params: {
+    reportIds: string[];
+    organizationId?: number;
+  }): Promise<BookingReportWithDetails[]> {
+    const where: Prisma.BookingReportWhereInput = {
+      id: { in: params.reportIds },
+    };
+
+    if (params.organizationId !== undefined) {
+      where.organizationId = params.organizationId;
+    }
+
     const reports = await this.prismaClient.bookingReport.findMany({
-      skip: params.skip,
-      take: params.take,
+      where,
       select: {
         id: true,
+        bookingUid: true,
+        bookerEmail: true,
         reportedById: true,
         reason: true,
         description: true,
+        cancelled: true,
         createdAt: true,
+        watchlistId: true,
+        reportedBy: {
+          select: {
+            id: true,
+            name: true,
+            email: true,
+          },
+        },
+        booking: {
+          select: {
+            id: true,
+            startTime: true,
+            endTime: true,
+            title: true,
+            uid: true,
+          },
+        },
+        watchlist: {
+          select: {
+            id: true,
+            type: true,
+            value: true,
+            action: true,
+            description: true,
+          },
+        },
       },
-      orderBy: { createdAt: "desc" },
     });
-    return reports;
+
+    return reports.map((report) => ({
+      ...report,
+      reporter: report.reportedBy,
+    }));
+  }
+
+  async deleteReport(params: { reportId: string; organizationId?: number }): Promise<void> {
+    const where: Prisma.BookingReportWhereInput & { id: string } = {
+      id: params.reportId,
+    };
+
+    if (params.organizationId !== undefined) {
+      where.organizationId = params.organizationId;
+    }
+
+    await this.prismaClient.bookingReport.delete({
+      where,
+    });
   }
 }
diff --git a/packages/lib/server/repository/watchlist.interface.ts b/packages/lib/server/repository/watchlist.interface.ts
index ee95d5d79ce8e2..8a006835151982 100644
--- a/packages/lib/server/repository/watchlist.interface.ts
+++ b/packages/lib/server/repository/watchlist.interface.ts
@@ -28,16 +28,18 @@ export interface WatchlistAuditEntry {
 export interface CreateWatchlistInput {
   type: WatchlistType;
   value: string;
-  organizationId: number;
+  organizationId?: number | null;
   action: WatchlistAction;
   description?: string;
   userId: number;
+  isGlobal?: boolean;
 }
 
 export interface CheckWatchlistInput {
   type: WatchlistType;
   value: string;
-  organizationId: number;
+  organizationId?: number | null;
+  isGlobal?: boolean;
 }
 
 export interface FindAllEntriesInput {
diff --git a/packages/lib/server/repository/watchlist.repository.ts b/packages/lib/server/repository/watchlist.repository.ts
index e648be6efed8c5..dcd008788f8a52 100644
--- a/packages/lib/server/repository/watchlist.repository.ts
+++ b/packages/lib/server/repository/watchlist.repository.ts
@@ -18,6 +18,7 @@ export class WatchlistRepository implements IWatchlistRepository {
       type: params.type,
       value: params.value,
       organizationId: params.organizationId,
+      isGlobal: params.isGlobal,
     });
 
     if (existing) {
@@ -29,11 +30,11 @@ export class WatchlistRepository implements IWatchlistRepository {
         data: {
           type: params.type,
           value: params.value,
-          organizationId: params.organizationId,
+          organizationId: params.organizationId ?? null,
           action: params.action,
           description: params.description,
           source: WatchlistSource.MANUAL,
-          isGlobal: false,
+          isGlobal: params.isGlobal ?? false,
         },
       });
 
@@ -55,12 +56,24 @@ export class WatchlistRepository implements IWatchlistRepository {
   }
 
   async checkExists(params: CheckWatchlistInput): Promise<WatchlistEntry | null> {
+    if (params.isGlobal) {
+      const entry = await this.prismaClient.watchlist.findFirst({
+        where: {
+          type: params.type,
+          value: params.value,
+          isGlobal: true,
+          organizationId: null,
+        },
+      });
+      return entry;
+    }
+
     const entry = await this.prismaClient.watchlist.findUnique({
       where: {
         type_value_organizationId: {
           type: params.type,
           value: params.value,
-          organizationId: params.organizationId,
+          organizationId: params.organizationId ?? null,
         },
       },
     });
diff --git a/packages/trpc/server/routers/viewer/admin/_router.ts b/packages/trpc/server/routers/viewer/admin/_router.ts
index b2c145727b25b9..cd020d74d3429b 100644
--- a/packages/trpc/server/routers/viewer/admin/_router.ts
+++ b/packages/trpc/server/routers/viewer/admin/_router.ts
@@ -1,8 +1,11 @@
 import { authedAdminProcedure } from "../../../procedures/authedProcedure";
 import { router } from "../../../trpc";
+import { ZAddToWatchlistInputSchema } from "./addToWatchlist.schema";
 import { ZAdminAssignFeatureToTeamSchema } from "./assignFeatureToTeam.schema";
 import { ZCreateSelfHostedLicenseSchema } from "./createSelfHostedLicenseKey.schema";
+import { ZDeleteBookingReportInputSchema } from "./deleteBookingReport.schema";
 import { ZAdminGetTeamsForFeatureSchema } from "./getTeamsForFeature.schema";
+import { ZListBookingReportsInputSchema } from "./listBookingReports.schema";
 import { ZListMembersSchema } from "./listPaginated.schema";
 import { ZAdminLockUserAccountSchema } from "./lockUserAccount.schema";
 import { ZAdminRemoveTwoFactor } from "./removeTwoFactor.schema";
@@ -19,10 +22,6 @@ import {
   workspacePlatformToggleEnabledSchema,
 } from "./workspacePlatform/schema";
 
-const NAMESPACE = "admin";
-
-const namespaced = (s: string) => `${NAMESPACE}.${s}`;
-
 export const adminRouter = router({
   listPaginated: authedAdminProcedure.input(ZListMembersSchema).query(async (opts) => {
     const { default: handler } = await import("./listPaginated.handler");
@@ -63,18 +62,14 @@ export const adminRouter = router({
     const { default: handler } = await import("./whitelistUserWorkflows.handler");
     return handler(opts);
   }),
-  getTeamsForFeature: authedAdminProcedure
-    .input(ZAdminGetTeamsForFeatureSchema)
-    .query(async (opts) => {
-      const { default: handler } = await import("./getTeamsForFeature.handler");
-      return handler(opts);
-    }),
-  assignFeatureToTeam: authedAdminProcedure
-    .input(ZAdminAssignFeatureToTeamSchema)
-    .mutation(async (opts) => {
-      const { default: handler } = await import("./assignFeatureToTeam.handler");
-      return handler(opts);
-    }),
+  getTeamsForFeature: authedAdminProcedure.input(ZAdminGetTeamsForFeatureSchema).query(async (opts) => {
+    const { default: handler } = await import("./getTeamsForFeature.handler");
+    return handler(opts);
+  }),
+  assignFeatureToTeam: authedAdminProcedure.input(ZAdminAssignFeatureToTeamSchema).mutation(async (opts) => {
+    const { default: handler } = await import("./assignFeatureToTeam.handler");
+    return handler(opts);
+  }),
   unassignFeatureFromTeam: authedAdminProcedure
     .input(ZAdminUnassignFeatureFromTeamSchema)
     .mutation(async (opts) => {
@@ -105,4 +100,16 @@ export const adminRouter = router({
       return handler(opts);
     }),
   }),
+  listBookingReports: authedAdminProcedure.input(ZListBookingReportsInputSchema).query(async (opts) => {
+    const { default: handler } = await import("./listBookingReports.handler");
+    return handler(opts);
+  }),
+  deleteBookingReport: authedAdminProcedure.input(ZDeleteBookingReportInputSchema).mutation(async (opts) => {
+    const { default: handler } = await import("./deleteBookingReport.handler");
+    return handler(opts);
+  }),
+  addToWatchlist: authedAdminProcedure.input(ZAddToWatchlistInputSchema).mutation(async (opts) => {
+    const { default: handler } = await import("./addToWatchlist.handler");
+    return handler(opts);
+  }),
 });
diff --git a/packages/trpc/server/routers/viewer/admin/addToWatchlist.handler.test.ts b/packages/trpc/server/routers/viewer/admin/addToWatchlist.handler.test.ts
new file mode 100644
index 00000000000000..5f0767636f322d
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/admin/addToWatchlist.handler.test.ts
@@ -0,0 +1,272 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+import { PrismaBookingReportRepository } from "@calcom/lib/server/repository/bookingReport";
+import { WatchlistRepository } from "@calcom/lib/server/repository/watchlist.repository";
+import { prisma } from "@calcom/prisma";
+import { WatchlistType, WatchlistAction, BookingReportReason } from "@calcom/prisma/enums";
+
+import { addToWatchlistHandler } from "./addToWatchlist.handler";
+
+vi.mock("@calcom/lib/server/repository/bookingReport");
+vi.mock("@calcom/lib/server/repository/watchlist.repository");
+vi.mock("@calcom/prisma", () => ({
+  prisma: {
+    bookingReport: {
+      findUnique: vi.fn(),
+    },
+  },
+}));
+
+describe("addToWatchlistHandler (Admin)", () => {
+  const mockUser = {
+    id: 1,
+    email: "admin@example.com",
+    role: "ADMIN" as const,
+  };
+
+  const mockReports = [
+    {
+      id: "report-1",
+      bookingId: 1,
+      bookerEmail: "spammer@example.com",
+      reportedById: 1,
+      reason: BookingReportReason.SPAM,
+      description: null,
+      cancelled: false,
+      createdAt: new Date(),
+      watchlistId: null,
+      reporter: { id: 1, name: "Admin", email: "admin@example.com" },
+      booking: {
+        id: 1,
+        startTime: new Date(),
+        endTime: new Date(),
+        title: "Test Booking",
+        uid: "booking-uid-1",
+      },
+      watchlist: null,
+    },
+    {
+      id: "report-2",
+      bookingId: 2,
+      bookerEmail: "user@spammer.com",
+      reportedById: 1,
+      reason: BookingReportReason.SPAM,
+      description: null,
+      cancelled: false,
+      createdAt: new Date(),
+      watchlistId: null,
+      reporter: { id: 1, name: "Admin", email: "admin@example.com" },
+      booking: {
+        id: 2,
+        startTime: new Date(),
+        endTime: new Date(),
+        title: "Test Booking 2",
+        uid: "booking-uid-2",
+      },
+      watchlist: null,
+    },
+  ];
+
+  const mockReportRepo = {
+    findReportsByIds: vi.fn(),
+    linkWatchlistToReport: vi.fn(),
+  };
+
+  const mockWatchlistRepo = {
+    checkExists: vi.fn(),
+    createEntry: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(PrismaBookingReportRepository).mockImplementation(() => mockReportRepo as any);
+    vi.mocked(WatchlistRepository).mockImplementation(() => mockWatchlistRepo as any);
+  });
+
+  describe("access control", () => {
+    it("should throw NOT_FOUND when report IDs don't exist", async () => {
+      mockReportRepo.findReportsByIds.mockResolvedValue([]);
+
+      await expect(
+        addToWatchlistHandler({
+          ctx: { user: mockUser },
+          input: {
+            reportIds: ["report-1", "report-2"],
+            type: WatchlistType.EMAIL,
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "NOT_FOUND",
+        message: expect.stringContaining("Booking report(s) not found"),
+      });
+    });
+
+    it("should throw NOT_FOUND with specific missing IDs", async () => {
+      mockReportRepo.findReportsByIds.mockResolvedValue([mockReports[0]]);
+
+      await expect(
+        addToWatchlistHandler({
+          ctx: { user: mockUser },
+          input: {
+            reportIds: ["report-1", "report-2", "report-3"],
+            type: WatchlistType.EMAIL,
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "NOT_FOUND",
+        message: expect.stringContaining("report-2, report-3"),
+      });
+    });
+
+  });
+
+  describe("duplicate prevention", () => {
+    it("should throw BAD_REQUEST when all reports are already in watchlist", async () => {
+      const reportsInWatchlist = mockReports.map((r) => ({ ...r, watchlistId: "watchlist-123" }));
+      mockReportRepo.findReportsByIds.mockResolvedValue(reportsInWatchlist);
+
+      await expect(
+        addToWatchlistHandler({
+          ctx: { user: mockUser },
+          input: {
+            reportIds: ["report-1", "report-2"],
+            type: WatchlistType.EMAIL,
+          },
+        })
+      ).rejects.toMatchObject({
+        code: "BAD_REQUEST",
+        message: "All selected bookers are already in the watchlist",
+      });
+    });
+  });
+
+  describe("successful addition", () => {
+    it("should create new global watchlist entry for EMAIL type and link report", async () => {
+      mockReportRepo.findReportsByIds.mockResolvedValue([mockReports[0]]);
+      mockWatchlistRepo.checkExists.mockResolvedValue(null);
+      mockWatchlistRepo.createEntry.mockResolvedValue({ id: "watchlist-new" });
+      mockReportRepo.linkWatchlistToReport.mockResolvedValue(undefined);
+
+      const result = await addToWatchlistHandler({
+        ctx: { user: mockUser },
+        input: {
+          reportIds: ["report-1"],
+          type: WatchlistType.EMAIL,
+          description: "Spam user",
+        },
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.addedCount).toBe(1);
+      expect(mockWatchlistRepo.checkExists).toHaveBeenCalledWith({
+        type: WatchlistType.EMAIL,
+        value: "spammer@example.com",
+        isGlobal: true,
+      });
+      expect(mockWatchlistRepo.createEntry).toHaveBeenCalledWith({
+        type: WatchlistType.EMAIL,
+        value: "spammer@example.com",
+        organizationId: null,
+        action: WatchlistAction.BLOCK,
+        description: "Spam user",
+        userId: 1,
+        isGlobal: true,
+      });
+      expect(mockReportRepo.linkWatchlistToReport).toHaveBeenCalledWith({
+        reportId: "report-1",
+        watchlistId: "watchlist-new",
+      });
+    });
+
+    it("should create new global watchlist entry for DOMAIN type and link report", async () => {
+      mockReportRepo.findReportsByIds.mockResolvedValue([mockReports[0]]);
+      mockWatchlistRepo.checkExists.mockResolvedValue(null);
+      mockWatchlistRepo.createEntry.mockResolvedValue({ id: "watchlist-domain" });
+      mockReportRepo.linkWatchlistToReport.mockResolvedValue(undefined);
+
+      const result = await addToWatchlistHandler({
+        ctx: { user: mockUser },
+        input: {
+          reportIds: ["report-1"],
+          type: WatchlistType.DOMAIN,
+        },
+      });
+
+      expect(result.success).toBe(true);
+      expect(mockWatchlistRepo.createEntry).toHaveBeenCalledWith({
+        type: WatchlistType.DOMAIN,
+        value: "example.com",
+        organizationId: null,
+        action: WatchlistAction.BLOCK,
+        description: undefined,
+        userId: 1,
+        isGlobal: true,
+      });
+    });
+
+    it("should reuse existing global watchlist entry when value already exists", async () => {
+      mockReportRepo.findReportsByIds.mockResolvedValue([mockReports[0]]);
+      mockWatchlistRepo.checkExists.mockResolvedValue({ id: "existing-watchlist" } as any);
+      mockReportRepo.linkWatchlistToReport.mockResolvedValue(undefined);
+
+      const result = await addToWatchlistHandler({
+        ctx: { user: mockUser },
+        input: {
+          reportIds: ["report-1"],
+          type: WatchlistType.EMAIL,
+        },
+      });
+
+      expect(result.success).toBe(true);
+      expect(mockWatchlistRepo.createEntry).not.toHaveBeenCalled();
+      expect(mockReportRepo.linkWatchlistToReport).toHaveBeenCalledWith({
+        reportId: "report-1",
+        watchlistId: "existing-watchlist",
+      });
+    });
+
+    it("should process multiple reports in batch", async () => {
+      mockReportRepo.findReportsByIds.mockResolvedValue(mockReports);
+      mockWatchlistRepo.checkExists.mockResolvedValue(null);
+      mockWatchlistRepo.createEntry
+        .mockResolvedValueOnce({ id: "watchlist-1" } as any)
+        .mockResolvedValueOnce({ id: "watchlist-2" } as any);
+      mockReportRepo.linkWatchlistToReport.mockResolvedValue(undefined);
+
+      const result = await addToWatchlistHandler({
+        ctx: { user: mockUser },
+        input: {
+          reportIds: ["report-1", "report-2"],
+          type: WatchlistType.EMAIL,
+        },
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.addedCount).toBe(2);
+      expect(result.results).toHaveLength(2);
+      expect(mockWatchlistRepo.createEntry).toHaveBeenCalledTimes(2);
+      expect(mockReportRepo.linkWatchlistToReport).toHaveBeenCalledTimes(2);
+    });
+
+    it("should return correct counts when processing multiple reports", async () => {
+      const mixedReports = [mockReports[0], { ...mockReports[1], watchlistId: "already-added" }];
+      mockReportRepo.findReportsByIds.mockResolvedValue(mixedReports);
+      mockWatchlistRepo.checkExists.mockResolvedValue(null);
+      mockWatchlistRepo.createEntry.mockResolvedValue({ id: "new-watchlist" } as any);
+      mockReportRepo.linkWatchlistToReport.mockResolvedValue(undefined);
+
+      const result = await addToWatchlistHandler({
+        ctx: { user: mockUser },
+        input: {
+          reportIds: ["report-1", "report-2"],
+          type: WatchlistType.EMAIL,
+        },
+      });
+
+      expect(result.addedCount).toBe(1);
+      expect(result.skippedCount).toBe(1);
+      expect(result.message).toBe("Successfully added 1 report(s) to watchlist");
+    });
+  });
+
+});
diff --git a/packages/trpc/server/routers/viewer/admin/addToWatchlist.handler.ts b/packages/trpc/server/routers/viewer/admin/addToWatchlist.handler.ts
new file mode 100644
index 00000000000000..b67cf842669e14
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/admin/addToWatchlist.handler.ts
@@ -0,0 +1,103 @@
+import { PrismaBookingReportRepository } from "@calcom/lib/server/repository/bookingReport";
+import { WatchlistRepository } from "@calcom/lib/server/repository/watchlist.repository";
+import { prisma } from "@calcom/prisma";
+import { WatchlistAction } from "@calcom/prisma/enums";
+
+import { TRPCError } from "@trpc/server";
+
+import type { TrpcSessionUser } from "../../../types";
+import type { TAddToWatchlistInputSchema } from "./addToWatchlist.schema";
+
+type AddToWatchlistOptions = {
+  ctx: {
+    user: NonNullable<TrpcSessionUser>;
+  };
+  input: TAddToWatchlistInputSchema;
+};
+
+export const addToWatchlistHandler = async ({ ctx, input }: AddToWatchlistOptions) => {
+  const { user } = ctx;
+  const bookingReportRepo = new PrismaBookingReportRepository(prisma);
+  const watchlistRepo = new WatchlistRepository(prisma);
+
+  const validReports = await bookingReportRepo.findReportsByIds({
+    reportIds: input.reportIds,
+  });
+
+  if (validReports.length !== input.reportIds.length) {
+    const foundIds = validReports.map((r) => r.id);
+    const missingIds = input.reportIds.filter((id) => !foundIds.includes(id));
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: `Booking report(s) not found: ${missingIds.join(", ")}`,
+    });
+  }
+
+  const reportsToAdd = validReports.filter((report) => !report.watchlistId);
+
+  if (reportsToAdd.length === 0) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "All selected bookers are already in the watchlist",
+    });
+  }
+
+  try {
+    const results = await Promise.all(
+      reportsToAdd.map(async (report) => {
+        const value =
+          input.type === "EMAIL"
+            ? report.bookerEmail
+            : report.bookerEmail.split("@")[1] || report.bookerEmail;
+
+        const existingWatchlist = await watchlistRepo.checkExists({
+          type: input.type,
+          value,
+          isGlobal: true,
+        });
+
+        let watchlistId: string;
+
+        if (existingWatchlist) {
+          watchlistId = existingWatchlist.id;
+        } else {
+          const newWatchlist = await watchlistRepo.createEntry({
+            type: input.type,
+            value,
+            organizationId: null,
+            action: WatchlistAction.BLOCK,
+            description: input.description,
+            userId: user.id,
+            isGlobal: true,
+          });
+          watchlistId = newWatchlist.id;
+        }
+
+        await bookingReportRepo.linkWatchlistToReport({
+          reportId: report.id,
+          watchlistId,
+        });
+
+        return { reportId: report.id, watchlistId, value };
+      })
+    );
+
+    return {
+      success: true,
+      message: `Successfully added ${reportsToAdd.length} report(s) to watchlist`,
+      addedCount: reportsToAdd.length,
+      skippedCount: validReports.length - reportsToAdd.length,
+      results: results.map((r) => ({ reportId: r.reportId, watchlistId: r.watchlistId })),
+    };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("already exists")) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "This entry already exists in the global watchlist",
+      });
+    }
+    throw error;
+  }
+};
+
+export default addToWatchlistHandler;
diff --git a/packages/trpc/server/routers/viewer/admin/addToWatchlist.schema.ts b/packages/trpc/server/routers/viewer/admin/addToWatchlist.schema.ts
new file mode 100644
index 00000000000000..b081ef675b99fd
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/admin/addToWatchlist.schema.ts
@@ -0,0 +1,11 @@
+import { z } from "zod";
+
+import { WatchlistType } from "@calcom/prisma/enums";
+
+export const ZAddToWatchlistInputSchema = z.object({
+  reportIds: z.array(z.string().uuid()).min(1),
+  type: z.nativeEnum(WatchlistType),
+  description: z.string().optional(),
+});
+
+export type TAddToWatchlistInputSchema = z.infer<typeof ZAddToWatchlistInputSchema>;
diff --git a/packages/trpc/server/routers/viewer/admin/deleteBookingReport.handler.test.ts b/packages/trpc/server/routers/viewer/admin/deleteBookingReport.handler.test.ts
new file mode 100644
index 00000000000000..01f25368b8a5bf
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/admin/deleteBookingReport.handler.test.ts
@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+import { PrismaBookingReportRepository } from "@calcom/lib/server/repository/bookingReport";
+
+import { deleteBookingReportHandler } from "./deleteBookingReport.handler";
+
+vi.mock("@calcom/lib/server/repository/bookingReport");
+
+describe("deleteBookingReportHandler (Admin)", () => {
+  const mockUser = {
+    id: 1,
+    email: "admin@example.com",
+    role: "ADMIN" as const,
+  };
+
+  const mockReportRepo = {
+    deleteReport: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(PrismaBookingReportRepository).mockImplementation(() => mockReportRepo as any);
+  });
+
+  describe("successful deletion", () => {
+    it("should successfully delete report without organizationId requirement", async () => {
+      mockReportRepo.deleteReport.mockResolvedValue(undefined);
+
+      const result = await deleteBookingReportHandler({
+        ctx: { user: mockUser },
+        input: {
+          reportId: "report-123",
+        },
+      });
+
+      expect(result.success).toBe(true);
+      expect(mockReportRepo.deleteReport).toHaveBeenCalledWith({
+        reportId: "report-123",
+      });
+    });
+
+    it("should call repository deleteReport with correct parameters", async () => {
+      mockReportRepo.deleteReport.mockResolvedValue(undefined);
+
+      await deleteBookingReportHandler({
+        ctx: { user: mockUser },
+        input: {
+          reportId: "different-report-456",
+        },
+      });
+
+      expect(mockReportRepo.deleteReport).toHaveBeenCalledWith({
+        reportId: "different-report-456",
+      });
+      expect(mockReportRepo.deleteReport).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("error handling", () => {
+    it("should propagate repository errors when report not found", async () => {
+      mockReportRepo.deleteReport.mockRejectedValue(new Error("Report not found"));
+
+      await expect(
+        deleteBookingReportHandler({
+          ctx: { user: mockUser },
+          input: {
+            reportId: "non-existent-report",
+          },
+        })
+      ).rejects.toThrow("Report not found");
+    });
+  });
+
+  describe("cross-organization access", () => {
+    it("should allow admin to delete reports from any organization", async () => {
+      mockReportRepo.deleteReport.mockResolvedValue(undefined);
+
+      const result = await deleteBookingReportHandler({
+        ctx: { user: mockUser },
+        input: {
+          reportId: "report-from-org-200",
+        },
+      });
+
+      expect(result.success).toBe(true);
+      expect(mockReportRepo.deleteReport).toHaveBeenCalledWith({
+        reportId: "report-from-org-200",
+      });
+    });
+  });
+});
diff --git a/packages/trpc/server/routers/viewer/admin/deleteBookingReport.handler.ts b/packages/trpc/server/routers/viewer/admin/deleteBookingReport.handler.ts
new file mode 100644
index 00000000000000..c3b7bb65323d74
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/admin/deleteBookingReport.handler.ts
@@ -0,0 +1,24 @@
+import { PrismaBookingReportRepository } from "@calcom/lib/server/repository/bookingReport";
+import { prisma } from "@calcom/prisma";
+
+import type { TrpcSessionUser } from "../../../types";
+import type { TDeleteBookingReportInputSchema } from "./deleteBookingReport.schema";
+
+type DeleteBookingReportOptions = {
+  ctx: {
+    user: NonNullable<TrpcSessionUser>;
+  };
+  input: TDeleteBookingReportInputSchema;
+};
+
+export const deleteBookingReportHandler = async ({ input }: DeleteBookingReportOptions) => {
+  const bookingReportRepo = new PrismaBookingReportRepository(prisma);
+
+  await bookingReportRepo.deleteReport({
+    reportId: input.reportId,
+  });
+
+  return { success: true };
+};
+
+export default deleteBookingReportHandler;
diff --git a/packages/trpc/server/routers/viewer/admin/deleteBookingReport.schema.ts b/packages/trpc/server/routers/viewer/admin/deleteBookingReport.schema.ts
new file mode 100644
index 00000000000000..2ed43063e7e038
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/admin/deleteBookingReport.schema.ts
@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const ZDeleteBookingReportInputSchema = z.object({
+  reportId: z.string().uuid(),
+});
+
+export type TDeleteBookingReportInputSchema = z.infer<typeof ZDeleteBookingReportInputSchema>;
diff --git a/packages/trpc/server/routers/viewer/admin/listBookingReports.handler.test.ts b/packages/trpc/server/routers/viewer/admin/listBookingReports.handler.test.ts
new file mode 100644
index 00000000000000..6fa2ed57556caf
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/admin/listBookingReports.handler.test.ts
@@ -0,0 +1,220 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+import { PrismaBookingReportRepository } from "@calcom/lib/server/repository/bookingReport";
+import { BookingReportReason } from "@calcom/prisma/enums";
+
+import { listBookingReportsHandler } from "./listBookingReports.handler";
+
+vi.mock("@calcom/lib/server/repository/bookingReport");
+
+describe("listBookingReportsHandler (Admin)", () => {
+  const mockUser = {
+    id: 1,
+    email: "admin@example.com",
+    role: "ADMIN" as const,
+  };
+
+  const mockReportData = {
+    rows: [
+      {
+        id: "report-1",
+        bookingId: 1,
+        bookerEmail: "user1@example.com",
+        reportedById: 1,
+        reason: BookingReportReason.SPAM,
+        description: null,
+        cancelled: false,
+        createdAt: new Date("2025-01-01"),
+        watchlistId: null,
+        reporter: { id: 1, name: "Admin", email: "admin@example.com" },
+        booking: {
+          id: 1,
+          startTime: new Date(),
+          endTime: new Date(),
+          title: "Test Booking",
+          uid: "uid-1",
+        },
+        watchlist: null,
+      },
+      {
+        id: "report-2",
+        bookingId: 2,
+        bookerEmail: "user2@example.com",
+        reportedById: 1,
+        reason: BookingReportReason.DONT_KNOW_PERSON,
+        description: "Unknown person",
+        cancelled: true,
+        createdAt: new Date("2025-01-02"),
+        watchlistId: "watchlist-123",
+        reporter: { id: 1, name: "Admin", email: "admin@example.com" },
+        booking: {
+          id: 2,
+          startTime: new Date(),
+          endTime: new Date(),
+          title: "Test Booking 2",
+          uid: "uid-2",
+        },
+        watchlist: {
+          id: "watchlist-123",
+          type: "EMAIL" as const,
+          value: "user2@example.com",
+          action: "REPORT" as const,
+          description: null,
+        },
+      },
+    ],
+    meta: { totalRowCount: 2 },
+  };
+
+  const mockReportRepo = {
+    findAllReportedBookings: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(PrismaBookingReportRepository).mockImplementation(() => mockReportRepo as any);
+  });
+
+  describe("successful listing", () => {
+    it("should return paginated booking reports across all organizations", async () => {
+      mockReportRepo.findAllReportedBookings.mockResolvedValue(mockReportData);
+
+      const result = await listBookingReportsHandler({
+        ctx: { user: mockUser },
+        input: {
+          limit: 10,
+          offset: 0,
+        },
+      });
+
+      expect(result).toEqual(mockReportData);
+      expect(result.rows).toHaveLength(2);
+      expect(result.meta.totalRowCount).toBe(2);
+      expect(mockReportRepo.findAllReportedBookings).toHaveBeenCalledWith({
+        skip: 0,
+        take: 10,
+        searchTerm: undefined,
+        filters: undefined,
+      });
+    });
+
+    it("should pass search term to repository", async () => {
+      mockReportRepo.findAllReportedBookings.mockResolvedValue(mockReportData);
+
+      await listBookingReportsHandler({
+        ctx: { user: mockUser },
+        input: {
+          limit: 10,
+          offset: 0,
+          searchTerm: "spam@example.com",
+        },
+      });
+
+      expect(mockReportRepo.findAllReportedBookings).toHaveBeenCalledWith({
+        skip: 0,
+        take: 10,
+        searchTerm: "spam@example.com",
+        filters: undefined,
+      });
+    });
+
+    it("should pass filters to repository", async () => {
+      mockReportRepo.findAllReportedBookings.mockResolvedValue(mockReportData);
+
+      const filters = {
+        reason: [BookingReportReason.SPAM, BookingReportReason.DONT_KNOW_PERSON],
+        cancelled: true,
+        hasWatchlist: false,
+      };
+
+      await listBookingReportsHandler({
+        ctx: { user: mockUser },
+        input: {
+          limit: 20,
+          offset: 10,
+          filters,
+        },
+      });
+
+      expect(mockReportRepo.findAllReportedBookings).toHaveBeenCalledWith({
+        skip: 10,
+        take: 20,
+        searchTerm: undefined,
+        filters,
+      });
+    });
+
+    it("should return rows and meta from repository", async () => {
+      const customData = {
+        rows: [mockReportData.rows[0]],
+        meta: { totalRowCount: 1 },
+      };
+      mockReportRepo.findAllReportedBookings.mockResolvedValue(customData);
+
+      const result = await listBookingReportsHandler({
+        ctx: { user: mockUser },
+        input: {
+          limit: 10,
+          offset: 0,
+        },
+      });
+
+      expect(result.rows).toHaveLength(1);
+      expect(result.meta.totalRowCount).toBe(1);
+    });
+  });
+
+  describe("pagination", () => {
+    it("should correctly pass limit and offset to repository", async () => {
+      mockReportRepo.findAllReportedBookings.mockResolvedValue({
+        rows: [],
+        meta: { totalRowCount: 0 },
+      });
+
+      await listBookingReportsHandler({
+        ctx: { user: mockUser },
+        input: {
+          limit: 50,
+          offset: 100,
+        },
+      });
+
+      expect(mockReportRepo.findAllReportedBookings).toHaveBeenCalledWith({
+        skip: 100,
+        take: 50,
+        searchTerm: undefined,
+        filters: undefined,
+      });
+    });
+  });
+
+  describe("cross-organization access", () => {
+    it("should allow admin to access reports from all organizations", async () => {
+      const crossOrgReports = {
+        rows: [
+          { ...mockReportData.rows[0], organizationId: 100 },
+          { ...mockReportData.rows[1], organizationId: 200 },
+        ],
+        meta: { totalRowCount: 2 },
+      };
+
+      mockReportRepo.findAllReportedBookings.mockResolvedValue(crossOrgReports);
+
+      const result = await listBookingReportsHandler({
+        ctx: { user: mockUser },
+        input: {
+          limit: 10,
+          offset: 0,
+        },
+      });
+
+      expect(result.rows).toHaveLength(2);
+      expect(mockReportRepo.findAllReportedBookings).toHaveBeenCalledWith({
+        skip: 0,
+        take: 10,
+        searchTerm: undefined,
+        filters: undefined,
+      });
+    });
+  });
+});
diff --git a/packages/trpc/server/routers/viewer/admin/listBookingReports.handler.ts b/packages/trpc/server/routers/viewer/admin/listBookingReports.handler.ts
new file mode 100644
index 00000000000000..e321ccef409630
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/admin/listBookingReports.handler.ts
@@ -0,0 +1,27 @@
+import { PrismaBookingReportRepository } from "@calcom/lib/server/repository/bookingReport";
+import { prisma } from "@calcom/prisma";
+
+import type { TrpcSessionUser } from "../../../types";
+import type { TListBookingReportsInputSchema } from "./listBookingReports.schema";
+
+type ListBookingReportsOptions = {
+  ctx: {
+    user: NonNullable<TrpcSessionUser>;
+  };
+  input: TListBookingReportsInputSchema;
+};
+
+export const listBookingReportsHandler = async ({ input }: ListBookingReportsOptions) => {
+  const bookingReportRepo = new PrismaBookingReportRepository(prisma);
+
+  const result = await bookingReportRepo.findAllReportedBookings({
+    skip: input.offset,
+    take: input.limit,
+    searchTerm: input.searchTerm,
+    filters: input.filters,
+  });
+
+  return result;
+};
+
+export default listBookingReportsHandler;
diff --git a/packages/trpc/server/routers/viewer/admin/listBookingReports.schema.ts b/packages/trpc/server/routers/viewer/admin/listBookingReports.schema.ts
new file mode 100644
index 00000000000000..843561fc84af7d
--- /dev/null
+++ b/packages/trpc/server/routers/viewer/admin/listBookingReports.schema.ts
@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+import { BookingReportReason } from "@calcom/prisma/enums";
+
+export const ZListBookingReportsInputSchema = z.object({
+  limit: z.number().min(1).max(100).optional(),
+  offset: z.number().min(0).optional(),
+  searchTerm: z.string().optional(),
+  filters: z
+    .object({
+      reason: z.array(z.nativeEnum(BookingReportReason)).optional(),
+      cancelled: z.boolean().optional(),
+      hasWatchlist: z.boolean().optional(),
+      dateRange: z
+        .object({
+          from: z.coerce.date().optional(),
+          to: z.coerce.date().optional(),
+        })
+        .optional(),
+    })
+    .optional(),
+});
+
+export type TListBookingReportsInputSchema = z.infer<typeof ZListBookingReportsInputSchema>;
diff --git a/packages/trpc/server/routers/viewer/organizations/_router.tsx b/packages/trpc/server/routers/viewer/organizations/_router.tsx
index e049e041e20b2e..04d720e2db7392 100644
--- a/packages/trpc/server/routers/viewer/organizations/_router.tsx
+++ b/packages/trpc/server/routers/viewer/organizations/_router.tsx
@@ -191,5 +191,4 @@ export const viewerOrganizationsRouter = router({
       const { default: handler } = await import("./getWatchlistEntryDetails.handler");
       return handler(opts);
     }),
-
 });