Billing & Licensing

const onboardingInput = {
  name: "Acme Corp",
  slug: "acme",
  orgOwnerEmail: "[email protected]",
  billingPeriod: "MONTHLY", // or "ANNUALLY"
  seats: 50,
  pricePerSeat: 37, // USD
};

const organizationPaymentService = new OrganizationPaymentService(user);
const onboarding = await organizationPaymentService
  .createOrganizationOnboarding(onboardingInput);

// Check for existing Stripe customer
const existingCustomer = await prisma.user.findUnique({
  where: { email: orgOwnerEmail },
  select: { metadata: true },
});

const stripeCustomerId = existingCustomer?.metadata?.stripeCustomerId
  ? existingCustomer.metadata.stripeCustomerId
  : await billingService.createCustomer({
      email: orgOwnerEmail,
      metadata: { email: orgOwnerEmail },
    });

const subscription = await billingService.createSubscriptionCheckout({
  customerId: stripeCustomerId,
  priceId: stripePriceId,
  quantity: seats,
  successUrl: `${WEBAPP_URL}/api/organizations/payment-redirect?session_id={CHECKOUT_SESSION_ID}&paymentStatus=success`,
  cancelUrl: `${WEBAPP_URL}/api/organizations/payment-redirect?session_id={CHECKOUT_SESSION_ID}&paymentStatus=failed`,
  metadata: {
    organizationOnboardingId: onboarding.id,
    seats,
    pricePerSeat,
    billingPeriod,
  },
  subscriptionData: {
    trial_period_days: ORG_TRIAL_DAYS, // Optional
    metadata: { source: "onboarding" },
  },
});

// Redirect user to: subscription.checkoutUrl

const customOnboarding = {
  ...onboardingInput,
  pricePerSeat: 29, // Custom price
  seats: 100,
  billingPeriod: "ANNUALLY",
};

// Requires admin permission
if (user.role !== UserPermissionRole.ADMIN) {
  // Permission check fails
  throw new ErrorWithCode(
    ErrorCode.Unauthorized,
    "You do not have permission to modify the default payment settings"
  );
}

const customPrice = await billingService.createPrice({
  amount: pricePerSeat * 100 * occurrence, // cents * months
  productId: process.env.STRIPE_ORG_PRODUCT_ID,
  currency: "usd",
  interval: billingPeriod === "MONTHLY" ? "month" : "year",
  nickname: `Custom Organization Price - $${pricePerSeat} per seat`,
  metadata: {
    organizationOnboardingId: onboarding.id,
    pricePerSeat,
    billingPeriod,
    createdAt: new Date().toISOString(),
  },
});

// Get unique members from teams
const memberships = await prisma.membership.findMany({
  where: { teamId: { in: teamIds } },
  select: { user: { select: { email: true } } },
  distinct: ["userId"],
});

const emailsSet = new Set(memberships.map(m => m.user.email));

// Add invited members
invitedMembers.forEach(member => emailsSet.add(member.email));

const uniqueMembersCount = emailsSet.size;

// Ensure meets minimum
const seats = Math.max(configuredSeats, uniqueMembersCount);

// Update subscription quantity
await stripe.subscriptions.update(subscriptionId, {
  items: [{
    id: subscriptionItemId,
    quantity: newSeatCount,
  }],
  proration_behavior: "always_invoice", // Immediate proration
});

type PlatformOrganizationBillingTaskPayload = {
  bookingUid: string;
  organizationId: number;
  eventTypeId: number;
  scheduledTime: Date;
  // Additional metadata
};

// Increment usage when booking is created
await billingTasker.incrementUsage({
  bookingUid: booking.uid,
  organizationId: organization.id,
  eventTypeId: eventType.id,
  scheduledTime: booking.startTime,
});

await billingTasker.cancelUsageIncrement({
  bookingUid: booking.uid,
});

await billingTasker.rescheduleUsageIncrement({
  bookingUid: booking.uid,
  rescheduledTime: newStartTime,
});

const monthlyConfig = {
  billingPeriod: "MONTHLY" as BillingPeriod,
  seats: 50,
  pricePerSeat: 37,
};

// Total: 50 seats × $37 = $1,850/month

const annualConfig = {
  billingPeriod: "ANNUALLY" as BillingPeriod,
  seats: 50,
  pricePerSeat: 37,
};

// Total: 50 seats × $37 × 12 months = $22,200/year
// (Paid upfront)

if (user.role === UserPermissionRole.ADMIN) {
  // Skip Stripe checkout
  return {
    organizationOnboarding,
    subscription: null,
    checkoutUrl: null,
    sessionId: null,
  };
}

General: /api/integrations/stripepayment/webhook
Billing: /api/organizations/billing/webhook
Apps: /api/app-store/stripepayment/webhook

import { OrganizationBilling } from "@calcom/features/ee/billing/organizations";

class InternalOrganizationBilling extends OrganizationBilling {
  async getStripeCustomerId(): Promise<string | null> {
    // Retrieve customer ID from database
    return this.repository.getStripeCustomerId(this.organization.id);
  }

  async getSubscriptionId(): Promise<string | null> {
    // Retrieve subscription ID
    return this.repository.getSubscriptionId(this.organization.id);
  }

  async getSubscriptionItems(): Promise<{ id: string; quantity: number }[]> {
    // Get subscription line items
    return this.repository.getSubscriptionItems(this.organization.id);
  }
}

STRIPE_PRIVATE_KEY=sk_xxx
STRIPE_ORG_PRODUCT_ID=prod_xxx
STRIPE_ORG_MONTHLY_PRICE_ID=price_xxx
STRIPE_ORG_ANNUAL_PRICE_ID=price_xxx

class OrganizationPaymentService {
  // Create organization onboarding
  async createOrganizationOnboarding(
    input: CreateOnboardingInput
  ): Promise<OrganizationOnboarding>;

  // Create payment intent and Stripe checkout
  async createPaymentIntent(
    input: CreatePaymentIntentInput,
    organizationOnboarding: OrganizationOnboarding
  ): Promise<{
    organizationOnboarding: OrganizationOnboarding;
    subscription: StripeSubscription | null;
    checkoutUrl: string | null;
    sessionId: string | null;
  }>;
}