SaaS

npm install @whop/sdk

pip install whop-sdk

import { WhopClient } from "@whop/sdk";

export const client = new WhopClient({ token: process.env.WHOP_API_KEY });

import os

from whop_sdk import Whop

client = Whop(token=os.environ["WHOP_API_KEY"])

export async function startCheckout(userId: string) {
  const checkout = await client.checkoutConfigurations.create({
    plan_id: process.env.WHOP_PLAN_ID!,
    metadata: { customer_id: userId },
    redirect_url: "https://yourapp.com/billing/return",
  });

  return checkout.purchase_url;
}

def start_checkout(user_id: str) -> str:
    checkout = client.checkout_configurations.create(
        plan_id=os.environ["WHOP_PLAN_ID"],
        metadata={"customer_id": user_id},
        redirect_url="https://yourapp.com/billing/return",
    )

    return checkout.purchase_url

// app/api/webhooks/whop/route.ts
import { unwrapWebhook } from "@whop/sdk/helpers";
import type { NextRequest } from "next/server";

export async function POST(request: NextRequest) {
  // Verify the raw body. Parsing it first changes the bytes and the signature check fails.
  const event = unwrapWebhook(await request.text(), {
    headers: Object.fromEntries(request.headers),
    key: process.env.WHOP_WEBHOOK_SECRET!,
  });

  if (event.type === "membership.activated") {
    const customerId = event.data.metadata?.customer_id;
    if (customerId && event.data.user_id) {
      await db.users.update(customerId, { whop_user_id: event.data.user_id });
    }
  }

  return new Response("OK", { status: 200 });
}

import os

from fastapi import FastAPI, Request, Response
from whop_sdk.lib.verify_webhook import unwrap

app = FastAPI()


@app.post("/api/webhooks/whop")
async def whop_webhook(request: Request):
    # Verify the raw body. Parsing it first changes the bytes and the signature check fails.
    event = unwrap(await request.body(), dict(request.headers), os.environ["WHOP_WEBHOOK_SECRET"])

    if event["type"] == "membership.activated":
        membership = event["data"]
        customer_id = (membership.get("metadata") or {}).get("customer_id")
        if customer_id and membership.get("user_id"):
            db.users.update(customer_id, whop_user_id=membership["user_id"])

    return Response(status_code=200)

export async function hasAccess(whopUserId: string) {
  const access = await client.users.checkAccess({
    id: whopUserId,
    resource_id: process.env.WHOP_PRODUCT_ID!,
  });

  return access.has_access;
}

def has_access(whop_user_id: str) -> bool:
    access = client.users.check_access(
        resource_id=os.environ["WHOP_PRODUCT_ID"],
        id=whop_user_id,
    )

    return access.has_access

// Add "past_due" if you let customers keep access while Whop retries a failed renewal.
const VALID_STATUSES = ["active", "trialing", "completed"];

export async function validateLicense(licenseKey: string, hwid: string) {
  // Retrieve accepts a license key in place of a membership ID. An unknown key throws a 404 error.
  const membership = await client.memberships.retrieve({ id: licenseKey });

  if (!VALID_STATUSES.includes(membership.status)) {
    return { valid: false, reason: "membership_inactive" };
  }

  const boundHwid = membership.metadata?.hwid;

  if (!boundHwid) {
    // Update merges these keys into the existing metadata.
    await client.memberships.update({ id: membership.id, metadata: { hwid } });
    return { valid: true };
  }

  if (boundHwid !== hwid) {
    return { valid: false, reason: "bound_to_another_machine" };
  }

  return { valid: true };
}

# Add "past_due" if you let customers keep access while Whop retries a failed renewal.
VALID_STATUSES = {"active", "trialing", "completed"}


def validate_license(license_key: str, hwid: str) -> dict:
    # Retrieve accepts a license key in place of a membership ID. An unknown key raises a 404 error.
    membership = client.memberships.retrieve(license_key)

    if membership.status not in VALID_STATUSES:
        return {"valid": False, "reason": "membership_inactive"}

    bound_hwid = (membership.metadata or {}).get("hwid")

    if not bound_hwid:
        # Update merges these keys into the existing metadata.
        client.memberships.update(membership.id, metadata={"hwid": hwid})
        return {"valid": True}

    if bound_hwid != hwid:
        return {"valid": False, "reason": "bound_to_another_machine"}

    return {"valid": True}