From 471b2687c458def7b5438d9d3297c0393bc061cc Mon Sep 17 00:00:00 2001
From: alannnc <alannnc@gmail.com>
Date: Fri, 11 Aug 2023 16:29:48 -0700
Subject: [PATCH] feat: app paypal payment (#8797)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: sean-brydon <55134778+sean-brydon@users.noreply.github.com>
Co-authored-by: Omar López <zomars@me.com>
---
 .../pages/api/integrations/paypal/webhook.ts  |   1 +
 apps/web/public/static/locales/en/common.json |   1 +
 packages/app-store/_pages/setup/index.tsx     |   1 +
 packages/app-store/apps.browser.generated.tsx |   1 +
 .../app-store/apps.keys-schemas.generated.ts  |   2 +
 packages/app-store/apps.metadata.generated.ts |   2 +
 packages/app-store/apps.schemas.generated.ts  |   2 +
 packages/app-store/apps.server.generated.ts   |   1 +
 packages/app-store/index.ts                   |   1 +
 packages/app-store/paypal/DESCRIPTION.md      |   8 +
 packages/app-store/paypal/api/add.ts          |  42 ++
 packages/app-store/paypal/api/capture.ts      |  94 +++++
 packages/app-store/paypal/api/index.ts        |   3 +
 .../components/EventTypeAppCardInterface.tsx  | 125 ++++++
 .../components/PaypalPaymentComponent.tsx     |  60 +++
 packages/app-store/paypal/config.json         |  18 +
 packages/app-store/paypal/index.ts            |   2 +
 .../app-store/paypal/lib/PaymentService.ts    | 202 +++++++++
 packages/app-store/paypal/lib/Paypal.ts       | 395 ++++++++++++++++++
 packages/app-store/paypal/lib/index.ts        |   1 +
 packages/app-store/paypal/package.json        |  14 +
 .../paypal/pages/setup/_getStaticProps.tsx    |  21 +
 .../app-store/paypal/pages/setup/index.tsx    | 197 +++++++++
 packages/app-store/paypal/static/1.jpeg       | Bin 0 -> 40993 bytes
 packages/app-store/paypal/static/2.jpeg       | Bin 0 -> 18701 bytes
 packages/app-store/paypal/static/3.jpeg       | Bin 0 -> 21231 bytes
 packages/app-store/paypal/static/icon.svg     |   5 +
 .../app-store/paypal/static/paypal-logo.svg   |   4 +
 packages/app-store/paypal/zod.ts              |  38 ++
 .../stripepayment/lib/PaymentService.ts       |  47 +--
 .../bookings/lib/handleCancelBooking.ts       |   2 +-
 .../ee/payments/api/paypal-webhook.ts         | 338 +++++++++++++++
 .../ee/payments/components/Payment.tsx        |  16 +-
 .../ee/payments/components/PaymentPage.tsx    |  22 +-
 .../features/ee/payments/pages/payment.tsx    |  28 +-
 packages/prisma/schema.prisma                 |   2 +-
 yarn.lock                                     |   9 +
 37 files changed, 1659 insertions(+), 46 deletions(-)
 create mode 100644 apps/web/pages/api/integrations/paypal/webhook.ts
 create mode 100644 packages/app-store/paypal/DESCRIPTION.md
 create mode 100644 packages/app-store/paypal/api/add.ts
 create mode 100644 packages/app-store/paypal/api/capture.ts
 create mode 100644 packages/app-store/paypal/api/index.ts
 create mode 100644 packages/app-store/paypal/components/EventTypeAppCardInterface.tsx
 create mode 100644 packages/app-store/paypal/components/PaypalPaymentComponent.tsx
 create mode 100644 packages/app-store/paypal/config.json
 create mode 100644 packages/app-store/paypal/index.ts
 create mode 100644 packages/app-store/paypal/lib/PaymentService.ts
 create mode 100644 packages/app-store/paypal/lib/Paypal.ts
 create mode 100644 packages/app-store/paypal/lib/index.ts
 create mode 100644 packages/app-store/paypal/package.json
 create mode 100644 packages/app-store/paypal/pages/setup/_getStaticProps.tsx
 create mode 100644 packages/app-store/paypal/pages/setup/index.tsx
 create mode 100644 packages/app-store/paypal/static/1.jpeg
 create mode 100644 packages/app-store/paypal/static/2.jpeg
 create mode 100644 packages/app-store/paypal/static/3.jpeg
 create mode 100644 packages/app-store/paypal/static/icon.svg
 create mode 100644 packages/app-store/paypal/static/paypal-logo.svg
 create mode 100644 packages/app-store/paypal/zod.ts
 create mode 100644 packages/features/ee/payments/api/paypal-webhook.ts

diff --git a/apps/web/pages/api/integrations/paypal/webhook.ts b/apps/web/pages/api/integrations/paypal/webhook.ts
new file mode 100644
index 0000000000..d085cb74cb
--- /dev/null
+++ b/apps/web/pages/api/integrations/paypal/webhook.ts
@@ -0,0 +1 @@
+export { default, config } from "@calcom/features/ee/payments/api/paypal-webhook";
diff --git a/apps/web/public/static/locales/en/common.json b/apps/web/public/static/locales/en/common.json
index 066a1ca9ba..f9318aa350 100644
--- a/apps/web/public/static/locales/en/common.json
+++ b/apps/web/public/static/locales/en/common.json
@@ -1903,6 +1903,7 @@
   "first_event_type_webhook_description": "Create your first webhook for this event type",
   "install_app_on": "Install app on",
   "create_for": "Create for",
+  "currency": "Currency",
   "setup_organization": "Setup an Organization",
   "organization_banner_description": "Create an environments where your teams can create shared apps, workflows and event types with round-robin and collective scheduling.",
   "organization_banner_title": "Manage organizations with multiple teams",
diff --git a/packages/app-store/_pages/setup/index.tsx b/packages/app-store/_pages/setup/index.tsx
index 6d5ae061b6..22331872a6 100644
--- a/packages/app-store/_pages/setup/index.tsx
+++ b/packages/app-store/_pages/setup/index.tsx
@@ -11,6 +11,7 @@ export const AppSetupMap = {
   zapier: dynamic(() => import("../../zapier/pages/setup")),
   closecom: dynamic(() => import("../../closecom/pages/setup")),
   sendgrid: dynamic(() => import("../../sendgrid/pages/setup")),
+  paypal: dynamic(() => import("../../paypal/pages/setup")),
 };
 
 export const AppSetupPage = (props: { slug: string }) => {
diff --git a/packages/app-store/apps.browser.generated.tsx b/packages/app-store/apps.browser.generated.tsx
index 1149b82063..a879018b4e 100644
--- a/packages/app-store/apps.browser.generated.tsx
+++ b/packages/app-store/apps.browser.generated.tsx
@@ -25,6 +25,7 @@ export const EventTypeAddonMap = {
   giphy: dynamic(() => import("./giphy/components/EventTypeAppCardInterface")),
   gtm: dynamic(() => import("./gtm/components/EventTypeAppCardInterface")),
   metapixel: dynamic(() => import("./metapixel/components/EventTypeAppCardInterface")),
+  paypal: dynamic(() => import("./paypal/components/EventTypeAppCardInterface")),
   plausible: dynamic(() => import("./plausible/components/EventTypeAppCardInterface")),
   qr_code: dynamic(() => import("./qr_code/components/EventTypeAppCardInterface")),
   stripepayment: dynamic(() => import("./stripepayment/components/EventTypeAppCardInterface")),
diff --git a/packages/app-store/apps.keys-schemas.generated.ts b/packages/app-store/apps.keys-schemas.generated.ts
index 5e28e70e72..b0086b3022 100644
--- a/packages/app-store/apps.keys-schemas.generated.ts
+++ b/packages/app-store/apps.keys-schemas.generated.ts
@@ -14,6 +14,7 @@ import { appKeysSchema as larkcalendar_zod_ts } from "./larkcalendar/zod";
 import { appKeysSchema as metapixel_zod_ts } from "./metapixel/zod";
 import { appKeysSchema as office365calendar_zod_ts } from "./office365calendar/zod";
 import { appKeysSchema as office365video_zod_ts } from "./office365video/zod";
+import { appKeysSchema as paypal_zod_ts } from "./paypal/zod";
 import { appKeysSchema as plausible_zod_ts } from "./plausible/zod";
 import { appKeysSchema as qr_code_zod_ts } from "./qr_code/zod";
 import { appKeysSchema as routing_forms_zod_ts } from "./routing-forms/zod";
@@ -43,6 +44,7 @@ export const appKeysSchemas = {
   metapixel: metapixel_zod_ts,
   office365calendar: office365calendar_zod_ts,
   office365video: office365video_zod_ts,
+  paypal: paypal_zod_ts,
   plausible: plausible_zod_ts,
   qr_code: qr_code_zod_ts,
   "routing-forms": routing_forms_zod_ts,
diff --git a/packages/app-store/apps.metadata.generated.ts b/packages/app-store/apps.metadata.generated.ts
index 94e8d7b00e..17dfaee2e6 100644
--- a/packages/app-store/apps.metadata.generated.ts
+++ b/packages/app-store/apps.metadata.generated.ts
@@ -32,6 +32,7 @@ import mirotalk_config_json from "./mirotalk/config.json";
 import n8n_config_json from "./n8n/config.json";
 import { metadata as office365calendar__metadata_ts } from "./office365calendar/_metadata";
 import office365video_config_json from "./office365video/config.json";
+import paypal_config_json from "./paypal/config.json";
 import ping_config_json from "./ping/config.json";
 import pipedream_config_json from "./pipedream/config.json";
 import plausible_config_json from "./plausible/config.json";
@@ -99,6 +100,7 @@ export const appStoreMetadata = {
   n8n: n8n_config_json,
   office365calendar: office365calendar__metadata_ts,
   office365video: office365video_config_json,
+  paypal: paypal_config_json,
   ping: ping_config_json,
   pipedream: pipedream_config_json,
   plausible: plausible_config_json,
diff --git a/packages/app-store/apps.schemas.generated.ts b/packages/app-store/apps.schemas.generated.ts
index 98c57b824f..deaabc768f 100644
--- a/packages/app-store/apps.schemas.generated.ts
+++ b/packages/app-store/apps.schemas.generated.ts
@@ -14,6 +14,7 @@ import { appDataSchema as larkcalendar_zod_ts } from "./larkcalendar/zod";
 import { appDataSchema as metapixel_zod_ts } from "./metapixel/zod";
 import { appDataSchema as office365calendar_zod_ts } from "./office365calendar/zod";
 import { appDataSchema as office365video_zod_ts } from "./office365video/zod";
+import { appDataSchema as paypal_zod_ts } from "./paypal/zod";
 import { appDataSchema as plausible_zod_ts } from "./plausible/zod";
 import { appDataSchema as qr_code_zod_ts } from "./qr_code/zod";
 import { appDataSchema as routing_forms_zod_ts } from "./routing-forms/zod";
@@ -43,6 +44,7 @@ export const appDataSchemas = {
   metapixel: metapixel_zod_ts,
   office365calendar: office365calendar_zod_ts,
   office365video: office365video_zod_ts,
+  paypal: paypal_zod_ts,
   plausible: plausible_zod_ts,
   qr_code: qr_code_zod_ts,
   "routing-forms": routing_forms_zod_ts,
diff --git a/packages/app-store/apps.server.generated.ts b/packages/app-store/apps.server.generated.ts
index 5016fe0356..01c09129f4 100644
--- a/packages/app-store/apps.server.generated.ts
+++ b/packages/app-store/apps.server.generated.ts
@@ -32,6 +32,7 @@ export const apiHandlers = {
   n8n: import("./n8n/api"),
   office365calendar: import("./office365calendar/api"),
   office365video: import("./office365video/api"),
+  paypal: import("./paypal/api"),
   ping: import("./ping/api"),
   pipedream: import("./pipedream/api"),
   plausible: import("./plausible/api"),
diff --git a/packages/app-store/index.ts b/packages/app-store/index.ts
index 54168d2e8d..5dd9d7face 100644
--- a/packages/app-store/index.ts
+++ b/packages/app-store/index.ts
@@ -14,6 +14,7 @@ const appStore = {
   office365calendar: () => import("./office365calendar"),
   office365video: () => import("./office365video"),
   plausible: () => import("./plausible"),
+  paypal: () => import("./paypal"),
   salesforce: () => import("./salesforce"),
   zohocrm: () => import("./zohocrm"),
   sendgrid: () => import("./sendgrid"),
diff --git a/packages/app-store/paypal/DESCRIPTION.md b/packages/app-store/paypal/DESCRIPTION.md
new file mode 100644
index 0000000000..a4b15502c3
--- /dev/null
+++ b/packages/app-store/paypal/DESCRIPTION.md
@@ -0,0 +1,8 @@
+---
+items:
+  - 1.jpeg
+  - 2.jpeg
+  - 3.jpeg
+---
+
+{DESCRIPTION}
diff --git a/packages/app-store/paypal/api/add.ts b/packages/app-store/paypal/api/add.ts
new file mode 100644
index 0000000000..bab1b9390c
--- /dev/null
+++ b/packages/app-store/paypal/api/add.ts
@@ -0,0 +1,42 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import prisma from "@calcom/prisma";
+
+import config from "../config.json";
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  if (!req.session?.user?.id) {
+    return res.status(401).json({ message: "You must be logged in to do this" });
+  }
+  const appType = config.type;
+  try {
+    const alreadyInstalled = await prisma.credential.findFirst({
+      where: {
+        type: appType,
+        userId: req.session.user.id,
+      },
+    });
+    if (alreadyInstalled) {
+      throw new Error("Already installed");
+    }
+    const installation = await prisma.credential.create({
+      data: {
+        type: appType,
+        key: {},
+        userId: req.session.user.id,
+        appId: "paypal",
+      },
+    });
+
+    if (!installation) {
+      throw new Error("Unable to create user credential for Paypal");
+    }
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      return res.status(500).json({ message: error.message });
+    }
+    return res.status(500);
+  }
+
+  return res.status(200).json({ url: "/apps/paypal/setup" });
+}
diff --git a/packages/app-store/paypal/api/capture.ts b/packages/app-store/paypal/api/capture.ts
new file mode 100644
index 0000000000..14c577f14c
--- /dev/null
+++ b/packages/app-store/paypal/api/capture.ts
@@ -0,0 +1,94 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+import z from "zod";
+
+import Paypal from "@calcom/app-store/paypal/lib/Paypal";
+import { findPaymentCredentials } from "@calcom/features/ee/payments/api/paypal-webhook";
+import { IS_PRODUCTION } from "@calcom/lib/constants";
+import { getErrorFromUnknown } from "@calcom/lib/errors";
+import prisma from "@calcom/prisma";
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  try {
+    // Look if it's get
+    if (req.method !== "GET") {
+      throw new Error("Invalid method");
+    }
+
+    // Look if bookingUid it's provided in query params using zod
+    const parseRequest = captureRequestSchema.safeParse(req.query);
+    if (!parseRequest.success) {
+      throw new Error("Request is malformed");
+    }
+
+    // Get bookingUid and token from query params
+    const { bookingUid, token } = parseRequest.data;
+
+    // Get booking credentials
+    const booking = await prisma.booking.findUnique({
+      where: {
+        uid: bookingUid,
+      },
+      select: {
+        id: true,
+        userId: true,
+      },
+    });
+
+    if (!booking) {
+      throw new Error("Booking not found");
+    }
+
+    const credentials = await findPaymentCredentials(booking?.id);
+
+    if (!credentials) {
+      throw new Error("Credentials not found");
+    }
+
+    // Get paypal instance
+    const paypalClient = new Paypal(credentials);
+
+    // capture payment
+    const capture = await paypalClient.captureOrder(token);
+
+    if (!capture) {
+      res.redirect(`/booking/${bookingUid}?paypalPaymentStatus=failed`);
+    }
+    if (IS_PRODUCTION) {
+      res.redirect(`/booking/${bookingUid}?paypalPaymentStatus=success`);
+    } else {
+      // For cal.dev, paypal sandbox doesn't send webhooks
+      const updateBooking = prisma.booking.update({
+        where: {
+          uid: bookingUid,
+        },
+        data: {
+          paid: true,
+        },
+      });
+      const updatePayment = prisma.payment.update({
+        where: {
+          id: booking?.id,
+        },
+        data: {
+          success: true,
+        },
+      });
+      await Promise.all([updateBooking, updatePayment]);
+      res.redirect(`/booking/${bookingUid}?paypalPaymentStatus=success`);
+    }
+    return;
+  } catch (_err) {
+    const err = getErrorFromUnknown(_err);
+
+    res.status(200).send({
+      message: err.message,
+      stack: IS_PRODUCTION ? undefined : err.stack,
+    });
+    res.redirect(`/booking/${req.query.bookingUid}?paypalPaymentStatus=failed`);
+  }
+}
+
+const captureRequestSchema = z.object({
+  bookingUid: z.string(),
+  token: z.string(),
+});
diff --git a/packages/app-store/paypal/api/index.ts b/packages/app-store/paypal/api/index.ts
new file mode 100644
index 0000000000..991a95c0c7
--- /dev/null
+++ b/packages/app-store/paypal/api/index.ts
@@ -0,0 +1,3 @@
+export { default as add } from "./add";
+export { default as webhook, config } from "@calcom/web/pages/api/integrations/paypal/webhook";
+export { default as capture } from "./capture";
diff --git a/packages/app-store/paypal/components/EventTypeAppCardInterface.tsx b/packages/app-store/paypal/components/EventTypeAppCardInterface.tsx
new file mode 100644
index 0000000000..fe90a8ed6c
--- /dev/null
+++ b/packages/app-store/paypal/components/EventTypeAppCardInterface.tsx
@@ -0,0 +1,125 @@
+import { useRouter } from "next/router";
+import { useState } from "react";
+
+import { useAppContextWithSchema } from "@calcom/app-store/EventTypeAppContext";
+import AppCard from "@calcom/app-store/_components/AppCard";
+import { currencyOptions } from "@calcom/app-store/paypal/pages/setup";
+import type { EventTypeAppCardComponent } from "@calcom/app-store/types";
+import { WEBAPP_URL } from "@calcom/lib/constants";
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { Alert, Select, TextField } from "@calcom/ui";
+
+import type { appDataSchema } from "../zod";
+import { PaypalPaymentOptions as paymentOptions } from "../zod";
+
+type Option = { value: string; label: string };
+
+const EventTypeAppCard: EventTypeAppCardComponent = function EventTypeAppCard({ app, eventType }) {
+  const { asPath } = useRouter();
+  const [getAppData, setAppData] = useAppContextWithSchema<typeof appDataSchema>();
+  const price = getAppData("price");
+  const currency = getAppData("currency");
+  const [selectedCurrency, setSelectedCurrency] = useState(
+    currencyOptions.find((c) => c.value === currency) || {
+      label: currencyOptions[0].label,
+      value: currencyOptions[0].value,
+    }
+  );
+  const paymentOption = getAppData("paymentOption");
+  const paymentOptionSelectValue = paymentOptions?.find((option) => paymentOption === option.value) || {
+    label: paymentOptions[0].label,
+    value: paymentOptions[0].value,
+  };
+  const seatsEnabled = !!eventType.seatsPerTimeSlot;
+  const [requirePayment, setRequirePayment] = useState(getAppData("enabled"));
+  const { t } = useLocale();
+  const recurringEventDefined = eventType.recurringEvent?.count !== undefined;
+
+  return (
+    <AppCard
+      returnTo={WEBAPP_URL + asPath}
+      setAppData={setAppData}
+      app={app}
+      switchChecked={requirePayment}
+      switchOnClick={(enabled) => {
+        setRequirePayment(enabled);
+      }}
+      description={<>Add Paypal payment to your events</>}>
+      <>
+        {recurringEventDefined ? (
+          <Alert className="mt-2" severity="warning" title={t("warning_recurring_event_payment")} />
+        ) : (
+          requirePayment && (
+            <>
+              <div className="mt-2 block items-center sm:flex">
+                <TextField
+                  label="Price"
+                  labelSrOnly
+                  addOnLeading="$"
+                  addOnSuffix={currency || "No selected currency"}
+                  step="0.01"
+                  min="0.5"
+                  type="number"
+                  required
+                  className="block w-full rounded-sm border-gray-300 pl-2 pr-12 text-sm"
+                  placeholder="Price"
+                  onChange={(e) => {
+                    setAppData("price", Number(e.target.value) * 100);
+                    if (currency) {
+                      setAppData("currency", currency);
+                    }
+                  }}
+                  value={price > 0 ? price / 100 : undefined}
+                />
+              </div>
+              <div className="mt-5 w-60">
+                <label className="text-default block text-sm font-medium" htmlFor="currency">
+                  {t("currency")}
+                </label>
+                <Select
+                  variant="default"
+                  options={currencyOptions}
+                  value={selectedCurrency}
+                  className="text-black"
+                  defaultValue={selectedCurrency}
+                  onChange={(e) => {
+                    if (e) {
+                      setSelectedCurrency(e);
+                      setAppData("currency", e.value);
+                    }
+                  }}
+                />
+              </div>
+
+              <div className="mt-2 w-60">
+                <label className="text-default block text-sm font-medium" htmlFor="currency">
+                  Payment option
+                </label>
+                <Select<Option>
+                  defaultValue={
+                    paymentOptionSelectValue
+                      ? { ...paymentOptionSelectValue, label: t(paymentOptionSelectValue.label) }
+                      : { ...paymentOptions[0], label: t(paymentOptions[0].label) }
+                  }
+                  options={paymentOptions.map((option) => {
+                    return { ...option, label: t(option.label) || option.label };
+                  })}
+                  onChange={(input) => {
+                    if (input) setAppData("paymentOption", input.value);
+                  }}
+                  className="mb-1 h-[38px] w-full"
+                  isDisabled={seatsEnabled}
+                />
+              </div>
+              {seatsEnabled && paymentOption === "HOLD" && (
+                <Alert className="mt-2" severity="warning" title={t("seats_and_no_show_fee_error")} />
+              )}
+            </>
+          )
+        )}
+      </>
+    </AppCard>
+  );
+};
+
+export default EventTypeAppCard;
diff --git a/packages/app-store/paypal/components/PaypalPaymentComponent.tsx b/packages/app-store/paypal/components/PaypalPaymentComponent.tsx
new file mode 100644
index 0000000000..8b63e45047
--- /dev/null
+++ b/packages/app-store/paypal/components/PaypalPaymentComponent.tsx
@@ -0,0 +1,60 @@
+import Link from "next/link";
+import z from "zod";
+
+interface IPaypalPaymentComponentProps {
+  payment: {
+    // Will be parsed on render
+    data: unknown;
+  };
+}
+
+// Create zod schema for data
+const PaymentPaypalDataSchema = z.object({
+  order: z
+    .object({
+      id: z.string(),
+      status: z.string(),
+      links: z.array(
+        z.object({
+          href: z.string(),
+          rel: z.string(),
+          method: z.string(),
+        })
+      ),
+    })
+    .optional(),
+  capture: z.object({}).optional(),
+});
+
+export const PaypalPaymentComponent = (props: IPaypalPaymentComponentProps) => {
+  const { payment } = props;
+  const { data } = payment;
+  const wrongUrl = (
+    <>
+      <p className="mt-3 text-center">Couldn&apos;t obtain payment URL</p>
+    </>
+  );
+
+  const parsedData = PaymentPaypalDataSchema.safeParse(data);
+  if (!parsedData.success || !parsedData.data?.order?.links) {
+    return wrongUrl;
+  }
+  const paymentUrl = parsedData.data.order.links.find(
+    (link) => link.rel === "approve" || link.rel === "payer-action"
+  )?.href;
+  if (!paymentUrl) {
+    return wrongUrl;
+  }
+  return (
+    <div className="mt-4 flex h-full w-full flex-col items-center justify-center">
+      <Link
+        href={`${paymentUrl}`}
+        className="inline-flex items-center justify-center rounded-2xl rounded-md border border-transparent bg-[#ffc439] px-12 py-2 text-base
+        font-medium text-black shadow-sm hover:brightness-95 focus:outline-none focus:ring-offset-2">
+        Pay with
+        <img src="/api/app-store/paypal/paypal-logo.svg" alt="Paypal" className="mx-2 mb-1 mt-2 w-16" />
+        <span />
+      </Link>
+    </div>
+  );
+};
diff --git a/packages/app-store/paypal/config.json b/packages/app-store/paypal/config.json
new file mode 100644
index 0000000000..f6a7ce84cd
--- /dev/null
+++ b/packages/app-store/paypal/config.json
@@ -0,0 +1,18 @@
+{
+  "name": "Paypal",
+  "slug": "paypal",
+  "type": "paypal_payment",
+  "logo": "icon.svg",
+  "url": "https://example.com/link",
+  "variant": "payment",
+  "categories": ["payment"],
+  "publisher": "Cal.com",
+  "email": "support@cal.com",
+  "description": "Paypal payment app by Cal.com",
+  "extendsFeature": "EventType",
+  "isTemplate": false,
+  "__createdUsingCli": true,
+  "imageSrc": "icon.svg",
+  "__template": "event-type-app-card",
+  "dirName": "paypal"
+}
diff --git a/packages/app-store/paypal/index.ts b/packages/app-store/paypal/index.ts
new file mode 100644
index 0000000000..e2e9d7b029
--- /dev/null
+++ b/packages/app-store/paypal/index.ts
@@ -0,0 +1,2 @@
+export * as api from "./api";
+export * as lib from "./lib";
diff --git a/packages/app-store/paypal/lib/PaymentService.ts b/packages/app-store/paypal/lib/PaymentService.ts
new file mode 100644
index 0000000000..4b7d7bcebb
--- /dev/null
+++ b/packages/app-store/paypal/lib/PaymentService.ts
@@ -0,0 +1,202 @@
+import type { Booking, Payment, PaymentOption, Prisma } from "@prisma/client";
+import { v4 as uuidv4 } from "uuid";
+import z from "zod";
+
+import Paypal from "@calcom/app-store/paypal/lib/Paypal";
+import { WEBAPP_URL } from "@calcom/lib/constants";
+import prisma from "@calcom/prisma";
+import type { CalendarEvent } from "@calcom/types/Calendar";
+import type { IAbstractPaymentService } from "@calcom/types/PaymentService";
+
+import { paymentOptionEnum } from "../zod";
+
+export const paypalCredentialKeysSchema = z.object({
+  client_id: z.string(),
+  secret_key: z.string(),
+  webhook_id: z.string(),
+});
+
+export class PaymentService implements IAbstractPaymentService {
+  private credentials: z.infer<typeof paypalCredentialKeysSchema>;
+
+  constructor(credentials: { key: Prisma.JsonValue }) {
+    this.credentials = paypalCredentialKeysSchema.parse(credentials.key);
+  }
+
+  async create(
+    payment: Pick<Prisma.PaymentUncheckedCreateInput, "amount" | "currency">,
+    bookingId: Booking["id"]
+  ) {
+    try {
+      const booking = await prisma.booking.findFirst({
+        select: {
+          uid: true,
+          title: true,
+        },
+        where: {
+          id: bookingId,
+        },
+      });
+      if (!booking) {
+        throw new Error();
+      }
+
+      const uid = uuidv4();
+
+      const paypalClient = new Paypal({
+        clientId: this.credentials.client_id,
+        secretKey: this.credentials.secret_key,
+      });
+      const orderResult = await paypalClient.createOrder({
+        referenceId: uid,
+        amount: payment.amount,
+        currency: payment.currency,
+        returnUrl: `${WEBAPP_URL}/api/integrations/paypal/capture?bookingUid=${booking.uid}`,
+        cancelUrl: `${WEBAPP_URL}/payment/${uid}`,
+      });
+      const paymentData = await prisma.payment.create({
+        data: {
+          uid,
+          app: {
+            connect: {
+              slug: "paypal",
+            },
+          },
+          booking: {
+            connect: {
+              id: bookingId,
+            },
+          },
+          amount: payment.amount,
+          externalId: orderResult.id,
+          currency: payment.currency,
+          data: Object.assign({}, { order: orderResult }) as unknown as Prisma.InputJsonValue,
+          fee: 0,
+          refunded: false,
+          success: false,
+        },
+      });
+
+      if (!paymentData) {
+        throw new Error();
+      }
+      return paymentData;
+    } catch (error) {
+      console.error(error);
+      throw new Error("Payment could not be created");
+    }
+  }
+  async update(): Promise<Payment> {
+    throw new Error("Method not implemented.");
+  }
+  async refund(): Promise<Payment> {
+    throw new Error("Method not implemented.");
+  }
+
+  async collectCard(
+    payment: Pick<Prisma.PaymentUncheckedCreateInput, "amount" | "currency">,
+    bookingId: number,
+    _bookerEmail: string,
+    paymentOption: PaymentOption
+  ): Promise<Payment> {
+    // Ensure that the payment service can support the passed payment option
+    if (paymentOptionEnum.parse(paymentOption) !== "HOLD") {
+      throw new Error("Payment option is not compatible with create method");
+    }
+    try {
+      const booking = await prisma.booking.findFirst({
+        select: {
+          uid: true,
+          title: true,
+        },
+        where: {
+          id: bookingId,
+        },
+      });
+      if (!booking) {
+        throw new Error();
+      }
+
+      const paymentData = await prisma.payment.create({
+        data: {
+          uid: uuidv4(),
+          app: {
+            connect: {
+              slug: "paypal",
+            },
+          },
+          booking: {
+            connect: {
+              id: bookingId,
+            },
+          },
+          amount: payment.amount,
+          currency: payment.currency,
+          data: {},
+          fee: 0,
+          refunded: false,
+          success: false,
+          paymentOption: paymentOption || "ON_BOOKING",
+        },
+      });
+
+      const paypalClient = new Paypal({
+        clientId: this.credentials.client_id,
+        secretKey: this.credentials.secret_key,
+      });
+      const preference = await paypalClient.createOrder({
+        referenceId: paymentData.uid,
+        amount: paymentData.amount,
+        currency: paymentData.currency,
+        returnUrl: `${WEBAPP_URL}/booking/${booking.uid}`,
+        cancelUrl: `${WEBAPP_URL}/payment/${paymentData.uid}`,
+        intent: "AUTHORIZE",
+      });
+
+      await prisma.payment.update({
+        where: {
+          id: paymentData.id,
+        },
+        data: {
+          externalId: preference?.id,
+          data: Object.assign({}, preference) as unknown as Prisma.InputJsonValue,
+        },
+      });
+
+      if (!paymentData) {
+        throw new Error();
+      }
+      return paymentData;
+    } catch (error) {
+      console.error(error);
+      throw new Error("Payment could not be created");
+    }
+  }
+  chargeCard(
+    payment: Pick<Prisma.PaymentUncheckedCreateInput, "amount" | "currency">,
+    bookingId: number
+  ): Promise<Payment> {
+    throw new Error("Method not implemented.");
+  }
+  getPaymentPaidStatus(): Promise<string> {
+    throw new Error("Method not implemented.");
+  }
+  getPaymentDetails(): Promise<Payment> {
+    throw new Error("Method not implemented.");
+  }
+  afterPayment(
+    event: CalendarEvent,
+    booking: {
+      user: { email: string | null; name: string | null; timeZone: string } | null;
+      id: number;
+      startTime: { toISOString: () => string };
+      uid: string;
+    },
+    paymentData: Payment
+  ): Promise<void> {
+    return Promise.resolve();
+  }
+  deletePayment(paymentId: number): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+}
diff --git a/packages/app-store/paypal/lib/Paypal.ts b/packages/app-store/paypal/lib/Paypal.ts
new file mode 100644
index 0000000000..eae742387c
--- /dev/null
+++ b/packages/app-store/paypal/lib/Paypal.ts
@@ -0,0 +1,395 @@
+import type { Prisma } from "@prisma/client";
+import { v4 as uuidv4 } from "uuid";
+import z from "zod";
+
+import { IS_PRODUCTION, WEBAPP_URL } from "@calcom/lib/constants";
+import prisma from "@calcom/prisma";
+
+class Paypal {
+  url: string;
+  clientId: string;
+  secretKey: string;
+  accessToken: string | null = null;
+  expiresAt: number | null = null;
+
+  constructor({ clientId, secretKey }: { clientId: string; secretKey: string }) {
+    this.url = IS_PRODUCTION ? "https://api-m.paypal.com" : "https://api-m.sandbox.paypal.com";
+    this.clientId = clientId;
+    this.secretKey = secretKey;
+  }
+
+  async getAccessToken(): Promise<void> {
+    if (this.accessToken && this.expiresAt && this.expiresAt > Date.now()) {
+      return;
+    }
+    const headers = {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Authorization: `Basic ${Buffer.from(`${this.clientId}:${this.secretKey}`).toString("base64")}`,
+    };
+
+    const body = new URLSearchParams();
+    body.append("grant_type", "client_credentials");
+
+    try {
+      const response = await fetch(`${this.url}/v1/oauth2/token`, {
+        method: "POST",
+        headers,
+        body,
+      });
+      if (response.ok) {
+        const { access_token, expires_in } = await response.json();
+        this.accessToken = access_token;
+        this.expiresAt = Date.now() + expires_in;
+      } else {
+        console.error(`Request failed with status ${response.status}`);
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
+  // Orders
+  async createOrder({
+    referenceId,
+    amount,
+    currency,
+    returnUrl,
+    cancelUrl,
+    intent = "CAPTURE",
+  }: {
+    referenceId: string;
+    amount: number;
+    currency: string;
+    returnUrl: string;
+    cancelUrl: string;
+    intent?: "CAPTURE" | "AUTHORIZE";
+  }): Promise<CreateOrderResponse> {
+    // Always get a new access token
+    await this.getAccessToken();
+
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.accessToken}`,
+      "PayPal-Request-Id": uuidv4(),
+    };
+
+    const createOrderRequestBody: CreateOrderRequestBody = {
+      intent,
+      purchase_units: [
+        {
+          reference_id: referenceId,
+          amount: {
+            currency_code: currency,
+            value: (amount / 100).toString(),
+          },
+        },
+      ],
+      payment_source: {
+        paypal: {
+          experience_context: {
+            user_action: "PAY_NOW",
+            return_url: returnUrl,
+            cancel_url: cancelUrl,
+          },
+        },
+      },
+    };
+
+    try {
+      const response = await fetch(`${this.url}/v2/checkout/orders`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(createOrderRequestBody),
+      });
+
+      if (response.ok) {
+        const createOrderResponse: CreateOrderResponse = await response.json();
+        return createOrderResponse;
+      } else {
+        console.error(`Request failed with status ${response.status}`);
+      }
+    } catch (error) {
+      console.error(error);
+    }
+    return {} as CreateOrderResponse;
+  }
+
+  async captureOrder(orderId: string): Promise<boolean> {
+    try {
+      await this.getAccessToken();
+
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.accessToken}`,
+      };
+
+      const captureResult = await fetch(`${this.url}/v2/checkout/orders/${orderId}/capture`, {
+        method: "POST",
+        headers,
+      });
+      if (captureResult.ok) {
+        const result = await captureResult.json();
+        if (result.body.status === "COMPLETED") {
+          // Get payment reference id
+
+          const payment = await prisma.payment.findFirst({
+            where: {
+              externalId: orderId,
+            },
+            select: {
+              id: true,
+              bookingId: true,
+              data: true,
+            },
+          });
+
+          if (!payment) {
+            throw new Error("Payment not found");
+          }
+
+          await prisma.payment.update({
+            where: {
+              id: payment?.id,
+            },
+            data: {
+              success: true,
+              data: Object.assign(
+                {},
+                { ...(payment?.data as Record<string, string | number>), capture: result.body.id }
+              ) as unknown as Prisma.InputJsonValue,
+            },
+          });
+
+          // Update booking as paid
+          await prisma.booking.update({
+            where: {
+              id: payment.bookingId,
+            },
+            data: {
+              status: "ACCEPTED",
+            },
+          });
+
+          return true;
+        }
+      }
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+    return false;
+  }
+
+  async createWebhook(): Promise<boolean | string> {
+    // Always get a new access token
+    await this.getAccessToken();
+
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.accessToken}`,
+    };
+
+    const body = {
+      url: `${WEBAPP_URL}/api/integrations/paypal/webhook`,
+      event_types: [
+        {
+          name: "CHECKOUT.ORDER.APPROVED",
+        },
+        {
+          name: "CHECKOUT.ORDER.COMPLETED",
+        },
+      ],
+    };
+
+    try {
+      const response = await fetch(`${this.url}/v1/notifications/webhooks`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+      });
+
+      if (response.ok) {
+        const result = await response.json();
+        return result.id as string;
+      }
+    } catch (error) {
+      console.error(error);
+    }
+
+    return false;
+  }
+
+  async listWebhooks(): Promise<string[]> {
+    // Always get a new access token
+    await this.getAccessToken();
+
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.accessToken}`,
+    };
+
+    try {
+      const response = await fetch(`${this.url}/v1/notifications/webhooks`, {
+        method: "GET",
+        headers,
+      });
+
+      if (response.ok) {
+        const { webhooks } = await response.json();
+
+        return webhooks
+          .filter((webhook: { id: string; url: string }) => {
+            return webhook.url.includes("api/integrations/paypal/webhook");
+          })
+          .map((webhook: { id: string }) => webhook.id);
+      }
+    } catch (error) {
+      console.error(error);
+      return [];
+    }
+    return [];
+  }
+
+  async deleteWebhook(webhookId: string): Promise<boolean> {
+    // Always get a new access token
+    await this.getAccessToken();
+
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.accessToken}`,
+    };
+
+    try {
+      const response = await fetch(`${this.url}/v1/notifications/webhooks/${webhookId}`, {
+        method: "DELETE",
+        headers,
+      });
+
+      if (response.ok) {
+        return true;
+      }
+    } catch (error) {
+      console.error(error);
+    }
+    return false;
+  }
+
+  async test(): Promise<boolean> {
+    // Always get a new access token
+    try {
+      await this.getAccessToken();
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+    return true;
+  }
+
+  async verifyWebhook(options: WebhookEventVerifyRequest): Promise<void> {
+    const url = `${this.url}/v1/notifications/verify-webhook-signature`;
+    const parseRequest = webhookEventVerifyRequestSchema.safeParse(options);
+
+    // Webhook event should be parsable
+    if (!parseRequest.success) {
+      console.error(parseRequest.error);
+      throw new Error("Request is malformed");
+    }
+
+    const stringy = JSON.stringify({
+      auth_algo: options.body.auth_algo,
+      cert_url: options.body.cert_url,
+      transmission_id: options.body.transmission_id,
+      transmission_sig: options.body.transmission_sig,
+      transmission_time: options.body.transmission_time,
+      webhook_id: options.body.webhook_id,
+    });
+
+    const bodyToString = stringy.slice(0, -1) + `,"webhook_event":${options.body.webhook_event}` + "}";
+
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.accessToken}`,
+        },
+        body: bodyToString,
+      });
+
+      if (!response.ok) {
+        throw response;
+      }
+      const data = await response.json();
+
+      if (data.verification_status !== "SUCCESS") {
+        throw data;
+      }
+    } catch (err) {
+      console.error(err);
+      throw err;
+    }
+  }
+}
+
+export default Paypal;
+
+interface PurchaseUnit {
+  amount: {
+    currency_code: string;
+    value: string;
+  };
+  reference_id: string;
+}
+
+interface ExperienceContext {
+  payment_method_preference?: string;
+  payment_method_selected?: string;
+  brand_name?: string;
+  locale?: string;
+  landing_page?: string;
+  shipping_preference?: string;
+  user_action: string;
+  return_url: string;
+  cancel_url: string;
+}
+
+interface PaymentSource {
+  paypal: {
+    experience_context: ExperienceContext;
+  };
+}
+
+interface CreateOrderRequestBody {
+  purchase_units: PurchaseUnit[];
+  intent: string;
+  payment_source?: PaymentSource;
+}
+
+interface Link {
+  href: string;
+  rel: string;
+  method: string;
+}
+
+interface CreateOrderResponse {
+  id: string;
+  status: string;
+  payment_source: PaymentSource;
+  links: Link[];
+}
+
+const webhookEventVerifyRequestSchema = z.object({
+  body: z
+    .object({
+      auth_algo: z.string(),
+      cert_url: z.string(),
+      transmission_id: z.string(),
+      transmission_sig: z.string(),
+      transmission_time: z.string(),
+      webhook_event: z.string(),
+      webhook_id: z.string(),
+    })
+    .required(),
+});
+
+export type WebhookEventVerifyRequest = z.infer<typeof webhookEventVerifyRequestSchema>;
diff --git a/packages/app-store/paypal/lib/index.ts b/packages/app-store/paypal/lib/index.ts
new file mode 100644
index 0000000000..392b144a8b
--- /dev/null
+++ b/packages/app-store/paypal/lib/index.ts
@@ -0,0 +1 @@
+export * from "./PaymentService";
diff --git a/packages/app-store/paypal/package.json b/packages/app-store/paypal/package.json
new file mode 100644
index 0000000000..c757a197d2
--- /dev/null
+++ b/packages/app-store/paypal/package.json
@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "private": true,
+  "name": "@calcom/paypal",
+  "version": "0.0.0",
+  "main": "./index.ts",
+  "dependencies": {
+    "@calcom/lib": "*"
+  },
+  "devDependencies": {
+    "@calcom/types": "*"
+  },
+  "description": "Paypal payment app by Cal.com"
+}
diff --git a/packages/app-store/paypal/pages/setup/_getStaticProps.tsx b/packages/app-store/paypal/pages/setup/_getStaticProps.tsx
new file mode 100644
index 0000000000..8faaca1338
--- /dev/null
+++ b/packages/app-store/paypal/pages/setup/_getStaticProps.tsx
@@ -0,0 +1,21 @@
+import type { GetStaticPropsContext } from "next";
+
+import getAppKeysFromSlug from "../../../_utils/getAppKeysFromSlug";
+
+export const getStaticProps = async (ctx: GetStaticPropsContext) => {
+  if (typeof ctx.params?.slug !== "string") return { notFound: true } as const;
+  let clientId = "";
+  let secretKey = "";
+  const appKeys = await getAppKeysFromSlug("paypal");
+  if (typeof appKeys.client_id === "string" && typeof appKeys.secret_key === "string") {
+    clientId = appKeys.client_id;
+    secretKey = appKeys.secret_key;
+  }
+
+  return {
+    props: {
+      clientId,
+      secretKey,
+    },
+  };
+};
diff --git a/packages/app-store/paypal/pages/setup/index.tsx b/packages/app-store/paypal/pages/setup/index.tsx
new file mode 100644
index 0000000000..cf028616f0
--- /dev/null
+++ b/packages/app-store/paypal/pages/setup/index.tsx
@@ -0,0 +1,197 @@
+import Link from "next/link";
+import { useRouter } from "next/router";
+import { useState } from "react";
+import { Toaster } from "react-hot-toast";
+
+import Paypal from "@calcom/app-store/paypal/lib/Paypal";
+import { useLocale } from "@calcom/lib/hooks/useLocale";
+import { trpc } from "@calcom/trpc";
+import { Button, showToast, TextField } from "@calcom/ui";
+
+export interface PayPalSetupProps {
+  public_key: string;
+  access_token: string;
+  currency: string;
+}
+
+export const currencyOptions = [
+  { label: "United States dollar", value: "USD" },
+  { label: "Australian dollar", value: "AUD" },
+  { label: "Brazilian real 2", value: "BRL" },
+  { label: "Canadian dollar", value: "CAD" },
+  { label: "Chinese Renmenbi 3", value: "CNY" },
+  { label: "Czech koruna", value: "CZK" },
+  { label: "Danish krone", value: "DKK" },
+  { label: "Euro", value: "EUR" },
+  { label: "Hong Kong dollar", value: "HKD" },
+  { label: "Hungarian forint 1", value: "HUF" },
+  { label: "Israeli new shekel", value: "ILS" },
+  { label: "Japanese yen 1", value: "JPY" },
+  { label: "Malaysian ringgit 3", value: "MYR" },
+  { label: "Mexican peso", value: "MXN" },
+  { label: "New Taiwan dollar 1", value: "TWD" },
+  { label: "New Zealand dollar", value: "NZD" },
+  { label: "Norwegian krone", value: "NOK" },
+  { label: "Philippine peso", value: "PHP" },
+  { label: "Polish złoty", value: "PLN" },
+  { label: "Pound sterling", value: "GBP" },
+  { label: "Russian ruble", value: "RUB" },
+  { label: "Singapore dollar", value: "SGD" },
+  { label: "Swedish krona", value: "SEK" },
+  { label: "Swiss franc", value: "CHF" },
+  { label: "Thai baht", value: "THB" },
+];
+
+export default function PayPalSetup(props: PayPalSetupProps) {
+  const [newClientId, setNewClientId] = useState("");
+  const [newSecretKey, setNewSecretKey] = useState("");
+
+  const router = useRouter();
+  const { t } = useLocale();
+
+  const integrations = trpc.viewer.integrations.useQuery({ variant: "payment" });
+  const paypalPaymentAppCredentials = integrations.data?.items.find((item) => item.type === "paypal_payment");
+  const [credentialId] = paypalPaymentAppCredentials?.userCredentialIds || [false];
+  const showContent = !!integrations.data && integrations.isSuccess && !!credentialId;
+  const saveKeysMutation = trpc.viewer.appsRouter.updateAppCredentials.useMutation({
+    onSuccess: () => {
+      showToast(t("keys_have_been_saved"), "success");
+      router.push("/event-types");
+    },
+    onError: (error) => {
+      showToast(error.message, "error");
+    },
+  });
+
+  const saveKeys = async (key: { clientId: string; secretKey: string }) => {
+    if (!key.clientId || !key.secretKey || key.clientId === key.secretKey) {
+      return false;
+    }
+    if (typeof credentialId !== "number") {
+      return;
+    }
+
+    // Test credentials before saving
+    const paypalClient = new Paypal({ clientId: key.clientId, secretKey: key.secretKey });
+    const test = await paypalClient.test();
+    if (!test) {
+      return false;
+    }
+
+    // Delete all existing webhooks
+    const webhooksToDelete = await paypalClient.listWebhooks();
+    if (webhooksToDelete) {
+      for (const webhook of webhooksToDelete) {
+        await paypalClient.deleteWebhook(webhook);
+      }
+    }
+
+    // Create webhook for this installation
+    const webhookId = await paypalClient.createWebhook();
+    if (!webhookId) {
+      // @TODO: make a button that tries to create the webhook again
+      console.log("Failed to create webhook", webhookId);
+      return false;
+    }
+    saveKeysMutation.mutate({
+      credentialId,
+      key: {
+        client_id: key.clientId,
+        secret_key: key.secretKey,
+        webhook_id: webhookId,
+      },
+    });
+
+    return true;
+  };
+
+  if (integrations.isLoading) {
+    return <div className="absolute z-50 flex h-screen w-full items-center bg-gray-200" />;
+  }
+
+  return (
+    <div className="bg-default flex h-screen">
+      {showContent ? (
+        <div className="bg-default border-subtle m-auto max-w-[43em] overflow-auto rounded border pb-10 md:p-10">
+          <div className="ml-2 ltr:mr-2 rtl:ml-2 md:ml-5">
+            <div className="invisible md:visible">
+              <img className="h-11" src="/api/app-store/paypal/icon.svg" alt="Paypal Payment Logo" />
+              <p className="text-default mt-5 text-lg">Paypal</p>
+            </div>
+            <form autoComplete="off" className="mt-5">
+              <TextField
+                label="Client Id"
+                type="text"
+                name="client_id"
+                id="client_id"
+                value={newClientId}
+                onChange={(e) => setNewClientId(e.target.value)}
+                role="presentation"
+              />
+
+              <TextField
+                label="Secret Key"
+                type="password"
+                name="access_token"
+                id="access_token"
+                value={newSecretKey}
+                autoComplete="new-password"
+                role="presentation"
+                onChange={(e) => setNewSecretKey(e.target.value)}
+              />
+
+              {/* Button to submit */}
+              <div className="mt-5 flex flex-row justify-end">
+                <Button
+                  color="secondary"
+                  onClick={() =>
+                    saveKeys({
+                      clientId: newClientId,
+                      secretKey: newSecretKey,
+                    })
+                  }>
+                  {t("save")}
+                </Button>
+              </div>
+            </form>
+            <div>
+              <p className="text-lgf text-default mt-5 font-bold">Setup instructions</p>
+
+              <ol className="text-default ml-1 list-decimal pl-2">
+                {/* @TODO: translate */}
+                <li>
+                  Log into your Paypal Developer account and create a new app{" "}
+                  <a
+                    target="_blank"
+                    href="https://developer.paypal.com/dashboard/applications/"
+                    className="text-orange-600 underline">
+                    {t("here")}
+                  </a>
+                  .
+                </li>
+                <li>Choose a name for your application.</li>
+                <li>Select Online payments solution.</li>
+                <li>Choose &quot;No&quot; for &quot;Using online platform&quot;.</li>
+                <li>CheckoutAPI as integration product.</li>
+                <li>Accept terms and Create APP.</li>
+                <li>Go back to dashboard, click on new app and copy the credentials.</li>
+                <li>Paste them on the required field and save them.</li>
+                <li>You&apos;re all setup.</li>
+              </ol>
+            </div>
+          </div>
+        </div>
+      ) : (
+        <div className="ml-5 mt-5">
+          <div>Paypal</div>
+          <div className="mt-3">
+            <Link href="/apps/paypal" passHref={true} legacyBehavior>
+              <Button>{t("go_to_app_store")}</Button>
+            </Link>
+          </div>
+        </div>
+      )}
+      <Toaster position="bottom-right" />
+    </div>
+  );
+}
diff --git a/packages/app-store/paypal/static/1.jpeg b/packages/app-store/paypal/static/1.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..9ea604e0ef7a4d5559daae77b97129acec21c8f8
GIT binary patch
literal 40993
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

literal 0
HcmV?d00001

diff --git a/packages/app-store/paypal/static/2.jpeg b/packages/app-store/paypal/static/2.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..34a89751d8d4debaa246a7f5c0c707615d67cedf
GIT binary patch
literal 18701
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

literal 0
HcmV?d00001

diff --git a/packages/app-store/paypal/static/3.jpeg b/packages/app-store/paypal/static/3.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..e3cd391d9f7581cbfb06428c57d8ddedbe667b2b
GIT binary patch
literal 21231
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
DJjKM2

literal 0
HcmV?d00001

diff --git a/packages/app-store/paypal/static/icon.svg b/packages/app-store/paypal/static/icon.svg
new file mode 100644
index 0000000000..532cabb91e
--- /dev/null
+++ b/packages/app-store/paypal/static/icon.svg
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 48 48">
+  <path fill="#001C64" d="M37.972 13.82c.107-5.565-4.485-9.837-10.799-9.837H14.115a1.278 1.278 0 0 0-1.262 1.079L7.62 37.758a1.038 1.038 0 0 0 1.025 1.2h7.737l-1.21 7.572a1.038 1.038 0 0 0 1.026 1.2H22.5c.305 0 .576-.11.807-.307.231-.198.269-.471.316-.772l1.85-10.885c.047-.3.2-.69.432-.888.231-.198.433-.306.737-.307H30.5c6.183 0 11.43-4.394 12.389-10.507.678-4.34-1.182-8.287-4.916-10.244Z"/>
+  <path fill="#0070E0" d="m18.056 26.9-1.927 12.22-1.21 7.664a1.038 1.038 0 0 0 1.026 1.2h6.67a1.278 1.278 0 0 0 1.261-1.079l1.758-11.14a1.277 1.277 0 0 1 1.261-1.078h3.927c6.183 0 11.429-4.51 12.388-10.623.68-4.339-1.504-8.286-5.238-10.244-.01.462-.05.923-.121 1.38-.959 6.112-6.206 10.623-12.389 10.623h-6.145a1.277 1.277 0 0 0-1.261 1.077Z"/>
+  <path fill="#003087" d="M16.128 39.12h-7.76a1.037 1.037 0 0 1-1.025-1.2l5.232-33.182a1.277 1.277 0 0 1 1.262-1.078h13.337c6.313 0 10.905 4.595 10.798 10.16-1.571-.824-3.417-1.295-5.44-1.295H21.413a1.278 1.278 0 0 0-1.261 1.078L18.057 26.9l-1.93 12.22Z"/>
+</svg>
\ No newline at end of file
diff --git a/packages/app-store/paypal/static/paypal-logo.svg b/packages/app-store/paypal/static/paypal-logo.svg
new file mode 100644
index 0000000000..fa72e83acc
--- /dev/null
+++ b/packages/app-store/paypal/static/paypal-logo.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="101" height="32" preserveAspectRatio="xMinYMin meet">
+  <path fill="#003087" d="M12.237 2.8h-7.8c-.5 0-1 .4-1.1.9l-3.1 20c-.1.4.2.7.6.7h3.7c.5 0 1-.4 1.1-.9l.8-5.4c.1-.5.5-.9 1.1-.9h2.5c5.1 0 8.1-2.5 8.9-7.4.3-2.1 0-3.8-1-5-1.1-1.3-3.1-2-5.7-2Zm.9 7.3c-.4 2.8-2.6 2.8-4.6 2.8h-1.2l.8-5.2c0-.3.3-.5.6-.5h.5c1.4 0 2.7 0 3.4.8.5.4.7 1.1.5 2.1ZM35.437 10h-3.7c-.3 0-.6.2-.6.5l-.2 1-.3-.4c-.8-1.2-2.6-1.6-4.4-1.6-4.1 0-7.6 3.1-8.3 7.5-.4 2.2.1 4.3 1.4 5.7 1.1 1.3 2.8 1.9 4.7 1.9 3.3 0 5.2-2.1 5.2-2.1l-.2 1c-.1.4.2.8.6.8h3.4c.5 0 1-.4 1.1-.9l2-12.8c.1-.2-.3-.6-.7-.6Zm-5.1 7.2c-.4 2.1-2 3.6-4.2 3.6-1.1 0-1.9-.3-2.5-1-.6-.7-.8-1.6-.6-2.6.3-2.1 2.1-3.6 4.2-3.6 1.1 0 1.9.4 2.5 1 .5.7.7 1.6.6 2.6ZM55.337 10h-3.7c-.4 0-.7.2-.9.5l-5.2 7.6-2.2-7.3c-.1-.5-.6-.8-1-.8h-3.7c-.4 0-.8.4-.6.9l4.1 12.1-3.9 5.4c-.3.4 0 1 .5 1h3.7c.4 0 .7-.2.9-.5l12.5-18c.3-.3 0-.9-.5-.9Z"/>
+  <path fill="#009cde" d="M67.737 2.8h-7.8c-.5 0-1 .4-1.1.9l-3.1 19.9c-.1.4.2.7.6.7h4c.4 0 .7-.3.7-.6l.9-5.7c.1-.5.5-.9 1.1-.9h2.5c5.1 0 8.1-2.5 8.9-7.4.3-2.1 0-3.8-1-5-1.2-1.2-3.1-1.9-5.7-1.9Zm.9 7.3c-.4 2.8-2.6 2.8-4.6 2.8h-1.2l.8-5.2c0-.3.3-.5.6-.5h.5c1.4 0 2.7 0 3.4.8.5.4.6 1.1.5 2.1ZM90.937 10h-3.7c-.3 0-.6.2-.6.5l-.2 1-.3-.4c-.8-1.2-2.6-1.6-4.4-1.6-4.1 0-7.6 3.1-8.3 7.5-.4 2.2.1 4.3 1.4 5.7 1.1 1.3 2.8 1.9 4.7 1.9 3.3 0 5.2-2.1 5.2-2.1l-.2 1c-.1.4.2.8.6.8h3.4c.5 0 1-.4 1.1-.9l2-12.8c0-.2-.3-.6-.7-.6Zm-5.2 7.2c-.4 2.1-2 3.6-4.2 3.6-1.1 0-1.9-.3-2.5-1-.6-.7-.8-1.6-.6-2.6.3-2.1 2.1-3.6 4.2-3.6 1.1 0 1.9.4 2.5 1 .6.7.8 1.6.6 2.6ZM95.337 3.3l-3.2 20.3c-.1.4.2.7.6.7h3.2c.5 0 1-.4 1.1-.9l3.2-19.9c.1-.4-.2-.7-.6-.7h-3.6c-.4 0-.6.2-.7.5Z"/>
+</svg>
diff --git a/packages/app-store/paypal/zod.ts b/packages/app-store/paypal/zod.ts
new file mode 100644
index 0000000000..32a6956ad3
--- /dev/null
+++ b/packages/app-store/paypal/zod.ts
@@ -0,0 +1,38 @@
+import { z } from "zod";
+
+import { eventTypeAppCardZod } from "@calcom/app-store/eventTypeAppCardZod";
+
+const paymentOptionSchema = z.object({
+  label: z.string(),
+  value: z.string(),
+});
+
+export const paymentOptionsSchema = z.array(paymentOptionSchema);
+
+export const PaypalPaymentOptions = [
+  {
+    label: "on_booking_option",
+    value: "ON_BOOKING",
+  },
+  // @TODO: not required right now
+  // {
+  //   label: "hold_option",
+  //   value: "HOLD",
+  // },
+];
+
+type PaymentOption = (typeof PaypalPaymentOptions)[number]["value"];
+const VALUES: [PaymentOption, ...PaymentOption[]] = [
+  PaypalPaymentOptions[0].value,
+  ...PaypalPaymentOptions.slice(1).map((option) => option.value),
+];
+export const paymentOptionEnum = z.enum(VALUES);
+
+export const appDataSchema = eventTypeAppCardZod.merge(
+  z.object({
+    price: z.number(),
+    currency: z.string(),
+    paymentOption: z.string().optional(),
+  })
+);
+export const appKeysSchema = z.object({});
diff --git a/packages/app-store/stripepayment/lib/PaymentService.ts b/packages/app-store/stripepayment/lib/PaymentService.ts
index 547ce428fb..9148384859 100644
--- a/packages/app-store/stripepayment/lib/PaymentService.ts
+++ b/packages/app-store/stripepayment/lib/PaymentService.ts
@@ -1,4 +1,4 @@
-import type { Booking, Payment, Prisma, PaymentOption } from "@prisma/client";
+import type { Booking, Payment, PaymentOption, Prisma } from "@prisma/client";
 import Stripe from "stripe";
 import { v4 as uuidv4 } from "uuid";
 import z from "zod";
@@ -12,7 +12,7 @@ import type { IAbstractPaymentService } from "@calcom/types/PaymentService";
 import { paymentOptionEnum } from "../zod";
 import { createPaymentLink } from "./client";
 import { retrieveOrCreateStripeCustomerByEmail } from "./customer";
-import type { StripeSetupIntentData, StripePaymentData } from "./server";
+import type { StripePaymentData, StripeSetupIntentData } from "./server";
 
 const stripeCredentialKeysSchema = z.object({
   stripe_user_id: z.string(),
@@ -38,6 +38,13 @@ export class PaymentService implements IAbstractPaymentService {
     });
   }
 
+  private async getPayment(where: Prisma.PaymentWhereInput) {
+    const payment = await prisma.payment.findFirst({ where });
+    if (!payment) throw new Error("Payment not found");
+    if (!payment.externalId) throw new Error("Payment externalId not found");
+    return { ...payment, externalId: payment.externalId };
+  }
+
   /* This method is for creating charges at the time of booking */
   async create(
     payment: Pick<Prisma.PaymentUncheckedCreateInput, "amount" | "currency">,
@@ -52,7 +59,7 @@ export class PaymentService implements IAbstractPaymentService {
       }
 
       // Load stripe keys
-      const stripeAppKeys = await prisma?.app.findFirst({
+      const stripeAppKeys = await prisma.app.findFirst({
         select: {
           keys: true,
         },
@@ -81,7 +88,7 @@ export class PaymentService implements IAbstractPaymentService {
         stripeAccount: this.credentials.stripe_user_id,
       });
 
-      const paymentData = await prisma?.payment.create({
+      const paymentData = await prisma.payment.create({
         data: {
           uid: uuidv4(),
           app: {
@@ -97,7 +104,6 @@ export class PaymentService implements IAbstractPaymentService {
           amount: payment.amount,
           currency: payment.currency,
           externalId: paymentIntent.id,
-
           data: Object.assign({}, paymentIntent, {
             stripe_publishable_key: this.credentials.stripe_publishable_key,
             stripeAccount: this.credentials.stripe_user_id,
@@ -131,7 +137,7 @@ export class PaymentService implements IAbstractPaymentService {
       }
 
       // Load stripe keys
-      const stripeAppKeys = await prisma?.app.findFirst({
+      const stripeAppKeys = await prisma.app.findFirst({
         select: {
           keys: true,
         },
@@ -161,7 +167,7 @@ export class PaymentService implements IAbstractPaymentService {
         stripeAccount: this.credentials.stripe_user_id,
       });
 
-      const paymentData = await prisma?.payment.create({
+      const paymentData = await prisma.payment.create({
         data: {
           uid: uuidv4(),
           app: {
@@ -177,7 +183,6 @@ export class PaymentService implements IAbstractPaymentService {
           amount: payment.amount,
           currency: payment.currency,
           externalId: setupIntent.id,
-
           data: Object.assign(
             {},
             {
@@ -202,7 +207,7 @@ export class PaymentService implements IAbstractPaymentService {
 
   async chargeCard(payment: Payment, _bookingId?: Booking["id"]): Promise<Payment> {
     try {
-      const stripeAppKeys = await prisma?.app.findFirst({
+      const stripeAppKeys = await prisma.app.findFirst({
         select: {
           keys: true,
         },
@@ -280,17 +285,11 @@ export class PaymentService implements IAbstractPaymentService {
 
   async refund(paymentId: Payment["id"]): Promise<Payment> {
     try {
-      const payment = await prisma.payment.findFirst({
-        where: {
-          id: paymentId,
-          success: true,
-          refunded: false,
-        },
+      const payment = await this.getPayment({
+        id: paymentId,
+        success: true,
+        refunded: false,
       });
-      if (!payment) {
-        throw new Error("Payment not found");
-      }
-
       const refund = await this.stripe.refunds.create(
         {
           payment_intent: payment.externalId,
@@ -345,15 +344,9 @@ export class PaymentService implements IAbstractPaymentService {
 
   async deletePayment(paymentId: Payment["id"]): Promise<boolean> {
     try {
-      const payment = await prisma.payment.findFirst({
-        where: {
-          id: paymentId,
-        },
+      const payment = await this.getPayment({
+        id: paymentId,
       });
-
-      if (!payment) {
-        throw new Error("Payment not found");
-      }
       const stripeAccount = (payment.data as unknown as StripePaymentData).stripeAccount;
 
       if (!stripeAccount) {
diff --git a/packages/features/bookings/lib/handleCancelBooking.ts b/packages/features/bookings/lib/handleCancelBooking.ts
index 9ca50ec819..eb32cc999b 100644
--- a/packages/features/bookings/lib/handleCancelBooking.ts
+++ b/packages/features/bookings/lib/handleCancelBooking.ts
@@ -503,7 +503,7 @@ async function handler(req: CustomRequest) {
     };
 
     const successPayment = bookingToDelete.payment.find((payment) => payment.success);
-    if (!successPayment) {
+    if (!successPayment?.externalId) {
       throw new Error("Cannot reject a booking without a successful payment");
     }
 
diff --git a/packages/features/ee/payments/api/paypal-webhook.ts b/packages/features/ee/payments/api/paypal-webhook.ts
new file mode 100644
index 0000000000..493626200b
--- /dev/null
+++ b/packages/features/ee/payments/api/paypal-webhook.ts
@@ -0,0 +1,338 @@
+import type { Prisma } from "@prisma/client";
+import type { NextApiRequest, NextApiResponse } from "next";
+import getRawBody from "raw-body";
+import * as z from "zod";
+
+import { paypalCredentialKeysSchema } from "@calcom/app-store/paypal/lib";
+import Paypal from "@calcom/app-store/paypal/lib/Paypal";
+import EventManager from "@calcom/core/EventManager";
+import { sendScheduledEmails } from "@calcom/emails";
+import { getCalEventResponses } from "@calcom/features/bookings/lib/getCalEventResponses";
+import { handleConfirmation } from "@calcom/features/bookings/lib/handleConfirmation";
+import { isPrismaObjOrUndefined, parseRecurringEvent } from "@calcom/lib";
+import { IS_PRODUCTION } from "@calcom/lib/constants";
+import { getErrorFromUnknown } from "@calcom/lib/errors";
+import { HttpError as HttpCode } from "@calcom/lib/http-error";
+import { getTranslation } from "@calcom/lib/server/i18n";
+import prisma, { bookingMinimalSelect } from "@calcom/prisma";
+import { BookingStatus } from "@calcom/prisma/enums";
+import type { CalendarEvent } from "@calcom/types/Calendar";
+
+export const config = {
+  api: {
+    bodyParser: false,
+  },
+};
+
+async function getEventType(id: number) {
+  return prisma.eventType.findUnique({
+    where: {
+      id,
+    },
+    select: {
+      recurringEvent: true,
+      requiresConfirmation: true,
+    },
+  });
+}
+
+export async function handlePaymentSuccess(
+  payload: z.infer<typeof eventSchema>,
+  rawPayload: string,
+  webhookHeaders: WebHookHeadersType
+) {
+  const payment = await prisma.payment.findFirst({
+    where: {
+      externalId: payload?.resource?.id,
+    },
+    select: {
+      id: true,
+      bookingId: true,
+      success: true,
+    },
+  });
+
+  if (!payment?.bookingId) throw new HttpCode({ statusCode: 204, message: "Payment not found" });
+
+  const booking = await prisma.booking.findUnique({
+    where: {
+      id: payment.bookingId,
+    },
+    select: {
+      ...bookingMinimalSelect,
+      eventType: true,
+      smsReminderNumber: true,
+      location: true,
+      eventTypeId: true,
+      userId: true,
+      uid: true,
+      paid: true,
+      destinationCalendar: true,
+      status: true,
+      responses: true,
+      user: {
+        select: {
+          id: true,
+          username: true,
+          credentials: true,
+          timeZone: true,
+          email: true,
+          name: true,
+          locale: true,
+          destinationCalendar: true,
+        },
+      },
+    },
+  });
+
+  if (!booking) throw new HttpCode({ statusCode: 204, message: "No booking found" });
+  // Probably booking it's already paid from /capture but we need to send confirmation email
+  const foundCredentials = await findPaymentCredentials(booking.id);
+  if (!foundCredentials) throw new HttpCode({ statusCode: 204, message: "No credentials found" });
+  const { webhookId, ...credentials } = foundCredentials;
+
+  const paypalClient = new Paypal(credentials);
+  await paypalClient.getAccessToken();
+  await paypalClient.verifyWebhook({
+    body: {
+      auth_algo: webhookHeaders["paypal-auth-algo"],
+      cert_url: webhookHeaders["paypal-cert-url"],
+      transmission_id: webhookHeaders["paypal-transmission-id"],
+      transmission_sig: webhookHeaders["paypal-transmission-sig"],
+      transmission_time: webhookHeaders["paypal-transmission-time"],
+      webhook_id: webhookId,
+      webhook_event: rawPayload,
+    },
+  });
+
+  type EventTypeRaw = Awaited<ReturnType<typeof getEventType>>;
+  let eventTypeRaw: EventTypeRaw | null = null;
+  if (booking.eventTypeId) {
+    eventTypeRaw = await getEventType(booking.eventTypeId);
+  }
+
+  const { user } = booking;
+
+  if (!user) throw new HttpCode({ statusCode: 204, message: "No user found" });
+
+  const t = await getTranslation(user.locale ?? "en", "common");
+  const attendeesListPromises = booking.attendees.map(async (attendee) => {
+    return {
+      name: attendee.name,
+      email: attendee.email,
+      timeZone: attendee.timeZone,
+      language: {
+        translate: await getTranslation(attendee.locale ?? "en", "common"),
+        locale: attendee.locale ?? "en",
+      },
+    };
+  });
+
+  const attendeesList = await Promise.all(attendeesListPromises);
+
+  const evt: CalendarEvent = {
+    type: booking.title,
+    title: booking.title,
+    description: booking.description || undefined,
+    startTime: booking.startTime.toISOString(),
+    endTime: booking.endTime.toISOString(),
+    customInputs: isPrismaObjOrUndefined(booking.customInputs),
+    ...getCalEventResponses({
+      booking: booking,
+      bookingFields: booking.eventType?.bookingFields || null,
+    }),
+    organizer: {
+      email: user.email,
+      name: user.name!,
+      timeZone: user.timeZone,
+      language: { translate: t, locale: user.locale ?? "en" },
+    },
+    attendees: attendeesList,
+    uid: booking.uid,
+    destinationCalendar: booking.destinationCalendar || user.destinationCalendar,
+    recurringEvent: parseRecurringEvent(eventTypeRaw?.recurringEvent),
+  };
+
+  if (booking.location) evt.location = booking.location;
+
+  const bookingData: Prisma.BookingUpdateInput = {
+    paid: true,
+    status: BookingStatus.ACCEPTED,
+  };
+
+  const isConfirmed = booking.status === BookingStatus.ACCEPTED;
+  if (isConfirmed) {
+    const eventManager = new EventManager(user);
+    const scheduleResult = await eventManager.create(evt);
+    bookingData.references = { create: scheduleResult.referencesToCreate };
+  }
+
+  if (eventTypeRaw?.requiresConfirmation) {
+    delete bookingData.status;
+  }
+
+  if (!payment?.success) {
+    await prisma.payment.update({
+      where: {
+        id: payment.id,
+      },
+      data: {
+        success: true,
+      },
+    });
+  }
+
+  if (booking.status === "PENDING") {
+    await prisma.booking.update({
+      where: {
+        id: booking.id,
+      },
+      data: bookingData,
+    });
+  }
+
+  if (!isConfirmed && !eventTypeRaw?.requiresConfirmation) {
+    await handleConfirmation({ user, evt, prisma, bookingId: booking.id, booking, paid: true });
+  } else {
+    await sendScheduledEmails({ ...evt });
+  }
+
+  throw new HttpCode({
+    statusCode: 200,
+    message: `Booking with id '${booking.id}' was paid and confirmed.`,
+  });
+}
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  try {
+    if (req.method !== "POST") {
+      throw new HttpCode({ statusCode: 405, message: "Method Not Allowed" });
+    }
+
+    const bodyRaw = await getRawBody(req);
+    const headers = req.headers;
+    const bodyAsString = bodyRaw.toString();
+
+    const parseHeaders = webhookHeadersSchema.safeParse(headers);
+    if (!parseHeaders.success) {
+      console.error(parseHeaders.error);
+      throw new HttpCode({ statusCode: 400, message: "Bad Request" });
+    }
+    const parse = eventSchema.safeParse(JSON.parse(bodyAsString));
+    if (!parse.success) {
+      console.error(parse.error);
+      throw new HttpCode({ statusCode: 400, message: "Bad Request" });
+    }
+
+    const { data: parsedPayload } = parse;
+
+    if (parsedPayload.event_type === "CHECKOUT.ORDER.APPROVED") {
+      return await handlePaymentSuccess(parsedPayload, bodyAsString, parseHeaders.data);
+    }
+  } catch (_err) {
+    const err = getErrorFromUnknown(_err);
+    console.error(`Webhook Error: ${err.message}`);
+    res.status(200).send({
+      message: err.message,
+      stack: IS_PRODUCTION ? undefined : err.stack,
+    });
+    return;
+  }
+
+  // Return a response to acknowledge receipt of the event
+  res.status(200).end();
+}
+
+const resourceSchema = z
+  .object({
+    create_time: z.string(),
+    id: z.string(),
+    payment_source: z.object({
+      paypal: z.object({}).optional(),
+    }),
+    intent: z.string(),
+    payer: z.object({
+      email_address: z.string(),
+      payer_id: z.string(),
+      address: z.object({
+        country_code: z.string(),
+      }),
+    }),
+    status: z.string().optional(),
+  })
+  .passthrough();
+
+const eventSchema = z
+  .object({
+    id: z.string(),
+    create_time: z.string(),
+    resource_type: z.string(),
+    event_type: z.string(),
+    summary: z.string(),
+    resource: resourceSchema,
+    status: z.string().optional(),
+    event_version: z.string(),
+    resource_version: z.string(),
+  })
+  .passthrough();
+
+const webhookHeadersSchema = z
+  .object({
+    "paypal-auth-algo": z.string(),
+    "paypal-cert-url": z.string(),
+    "paypal-transmission-id": z.string(),
+    "paypal-transmission-sig": z.string(),
+    "paypal-transmission-time": z.string(),
+  })
+  .passthrough();
+
+type WebHookHeadersType = z.infer<typeof webhookHeadersSchema>;
+
+export const findPaymentCredentials = async (
+  bookingId: number
+): Promise<{ clientId: string; secretKey: string; webhookId: string }> => {
+  try {
+    // @TODO: what about team bookings with paypal?
+    const userFromBooking = await prisma?.booking.findFirst({
+      where: {
+        id: bookingId,
+      },
+      select: {
+        id: true,
+        userId: true,
+      },
+    });
+
+    if (!userFromBooking) throw new Error("No user found");
+
+    const credentials = await prisma?.credential.findFirst({
+      where: {
+        appId: "paypal",
+        userId: userFromBooking?.userId,
+      },
+      select: {
+        key: true,
+      },
+    });
+    if (!credentials) {
+      throw new Error("No credentials found");
+    }
+    const parsedCredentials = paypalCredentialKeysSchema.safeParse(credentials?.key);
+    if (!parsedCredentials.success) {
+      throw new Error("Credentials malformed");
+    }
+
+    return {
+      clientId: parsedCredentials.data.client_id,
+      secretKey: parsedCredentials.data.secret_key,
+      webhookId: parsedCredentials.data.webhook_id,
+    };
+  } catch (err) {
+    console.error(err);
+    return {
+      clientId: "",
+      secretKey: "",
+      webhookId: "",
+    };
+  }
+};
diff --git a/packages/features/ee/payments/components/Payment.tsx b/packages/features/ee/payments/components/Payment.tsx
index cfe0f74be4..4f6185d3ee 100644
--- a/packages/features/ee/payments/components/Payment.tsx
+++ b/packages/features/ee/payments/components/Payment.tsx
@@ -7,7 +7,6 @@ import type { SyntheticEvent } from "react";
 import { useEffect, useState } from "react";
 
 import getStripe from "@calcom/app-store/stripepayment/lib/client";
-import type { StripePaymentData, StripeSetupIntentData } from "@calcom/app-store/stripepayment/lib/server";
 import { useBookingSuccessRedirect } from "@calcom/lib/bookingSuccessRedirect";
 import { CAL_URL } from "@calcom/lib/constants";
 import { useLocale } from "@calcom/lib/hooks/useLocale";
@@ -17,13 +16,14 @@ import type { EventType } from ".prisma/client";
 
 type Props = {
   payment: Omit<Payment, "id" | "fee" | "success" | "refunded" | "externalId" | "data"> & {
-    data: StripePaymentData | StripeSetupIntentData;
+    data: Record<string, unknown>;
   };
   eventType: { id: number; successRedirectUrl: EventType["successRedirectUrl"] };
   user: { username: string | null };
   location?: string | null;
   bookingId: number;
   bookingUid: string;
+  clientSecret: string;
 };
 
 type States =
@@ -162,26 +162,18 @@ const ELEMENT_STYLES_DARK: stripejs.Appearance = {
 };
 
 export default function PaymentComponent(props: Props) {
-  const stripePromise = getStripe((props.payment.data as StripePaymentData).stripe_publishable_key);
-  const paymentOption = props.payment.paymentOption;
+  const stripePromise = getStripe(props.payment.data.stripe_publishable_key as any);
   const [darkMode, setDarkMode] = useState<boolean>(false);
-  let clientSecret: string | null;
 
   useEffect(() => {
     setDarkMode(window.matchMedia("(prefers-color-scheme: dark)").matches);
   }, []);
 
-  if (paymentOption === "HOLD" && "setupIntent" in props.payment.data) {
-    clientSecret = props.payment.data.setupIntent.client_secret;
-  } else if (!("setupIntent" in props.payment.data)) {
-    clientSecret = props.payment.data.client_secret;
-  }
-
   return (
     <Elements
       stripe={stripePromise}
       options={{
-        clientSecret: clientSecret!,
+        clientSecret: props.clientSecret,
         appearance: darkMode ? ELEMENT_STYLES_DARK : ELEMENT_STYLES,
       }}>
       <PaymentForm {...props} />
diff --git a/packages/features/ee/payments/components/PaymentPage.tsx b/packages/features/ee/payments/components/PaymentPage.tsx
index 5b33f03911..e49bd8a68d 100644
--- a/packages/features/ee/payments/components/PaymentPage.tsx
+++ b/packages/features/ee/payments/components/PaymentPage.tsx
@@ -1,4 +1,5 @@
 import classNames from "classnames";
+import dynamic from "next/dynamic";
 import Head from "next/head";
 import type { FC } from "react";
 import { useEffect, useState } from "react";
@@ -15,7 +16,20 @@ import { localStorage } from "@calcom/lib/webstorage";
 import { CreditCard } from "@calcom/ui/components/icon";
 
 import type { PaymentPageProps } from "../pages/payment";
-import PaymentComponent from "./Payment";
+
+const StripePaymentComponent = dynamic(() => import("./Payment"), {
+  ssr: false,
+});
+
+const PaypalPaymentComponent = dynamic(
+  () =>
+    import("@calcom/app-store/paypal/components/PaypalPaymentComponent").then(
+      (m) => m.PaypalPaymentComponent
+    ),
+  {
+    ssr: false,
+  }
+);
 
 const PaymentPage: FC<PaymentPageProps> = (props) => {
   const { t, i18n } = useLocale();
@@ -119,7 +133,8 @@ const PaymentPage: FC<PaymentPageProps> = (props) => {
                     <div className="text-default mt-4 text-center dark:text-gray-300">{t("paid")}</div>
                   )}
                   {props.payment.appId === "stripe" && !props.payment.success && (
-                    <PaymentComponent
+                    <StripePaymentComponent
+                      clientSecret={props.clientSecret}
                       payment={props.payment}
                       eventType={props.eventType}
                       user={props.user}
@@ -128,6 +143,9 @@ const PaymentPage: FC<PaymentPageProps> = (props) => {
                       bookingUid={props.booking.uid}
                     />
                   )}
+                  {props.payment.appId === "paypal" && !props.payment.success && (
+                    <PaypalPaymentComponent payment={props.payment} />
+                  )}
                   {props.payment.refunded && (
                     <div className="text-default mt-4 text-center dark:text-gray-300">{t("refunded")}</div>
                   )}
diff --git a/packages/features/ee/payments/pages/payment.tsx b/packages/features/ee/payments/pages/payment.tsx
index 65a7d637bd..2dd032035a 100644
--- a/packages/features/ee/payments/pages/payment.tsx
+++ b/packages/features/ee/payments/pages/payment.tsx
@@ -1,13 +1,13 @@
+import type { Payment } from "@prisma/client";
 import type { GetServerSidePropsContext } from "next";
 import { z } from "zod";
 
-import type { StripePaymentData, StripeSetupIntentData } from "@calcom/app-store/stripepayment/lib/server";
 import prisma from "@calcom/prisma";
 import { BookingStatus } from "@calcom/prisma/enums";
 import { EventTypeMetaDataSchema } from "@calcom/prisma/zod-utils";
 import type { inferSSRProps } from "@calcom/types/inferSSRProps";
 
-import { ssrInit } from "@server/lib/ssr";
+import { ssrInit } from "../../../../../apps/web/server/lib/ssr";
 
 export type PaymentPageProps = inferSSRProps<typeof getServerSideProps>;
 
@@ -88,9 +88,10 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
   if (!rawPayment) return { notFound: true };
 
   const { data, booking: _booking, ...restPayment } = rawPayment;
+
   const payment = {
     ...restPayment,
-    data: data as unknown as StripePaymentData | StripeSetupIntentData,
+    data: data as Record<string, unknown>,
   };
 
   if (!_booking) return { notFound: true };
@@ -135,7 +136,28 @@ export const getServerSideProps = async (context: GetServerSidePropsContext) =>
       booking,
       trpcState: ssr.dehydrate(),
       payment,
+      clientSecret: getClientSecretFromPayment(payment),
       profile,
     },
   };
 };
+
+function hasStringProp<T extends string>(x: unknown, key: T): x is { [key in T]: string } {
+  return !!x && typeof x === "object" && key in x;
+}
+
+function getClientSecretFromPayment(
+  payment: Omit<Partial<Payment>, "data"> & { data: Record<string, unknown> }
+) {
+  if (
+    payment.paymentOption === "HOLD" &&
+    hasStringProp(payment.data, "setupIntent") &&
+    hasStringProp(payment.data.setupIntent, "client_secret")
+  ) {
+    return payment.data.setupIntent.client_secret;
+  }
+  if (hasStringProp(payment.data, "client_secret")) {
+    return payment.data.client_secret;
+  }
+  return "";
+}
diff --git a/packages/prisma/schema.prisma b/packages/prisma/schema.prisma
index eae1bce7d1..2509ec804e 100644
--- a/packages/prisma/schema.prisma
+++ b/packages/prisma/schema.prisma
@@ -509,7 +509,7 @@ model Payment {
   success       Boolean
   refunded      Boolean
   data          Json
-  externalId    String         @unique
+  externalId    String?        @unique
   paymentOption PaymentOption? @default(ON_BOOKING)
 
   @@index([bookingId])
diff --git a/yarn.lock b/yarn.lock
index 02fcdf641a..c06145e873 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4426,6 +4426,15 @@ __metadata:
   languageName: unknown
   linkType: soft
 
+"@calcom/paypal@workspace:packages/app-store/paypal":
+  version: 0.0.0-use.local
+  resolution: "@calcom/paypal@workspace:packages/app-store/paypal"
+  dependencies:
+    "@calcom/lib": "*"
+    "@calcom/types": "*"
+  languageName: unknown
+  linkType: soft
+
 "@calcom/ping@workspace:packages/app-store/ping":
   version: 0.0.0-use.local
   resolution: "@calcom/ping@workspace:packages/app-store/ping"