Full Example

const CUPRICE = "https://app.cuprice.io";

export type PlanFeature = { name: string; limit: number | null };

export type PricedPlan = {
  cupricePlanId: number; // 0 for a custom plan
  name: string;
  amount: number;
  currency: string;
  interval: "month" | "year";
  features: PlanFeature[];
};

function toPricedPlan(payload: any): PricedPlan {
  return {
    cupricePlanId: payload.plan.id,
    name: payload.plan.name,
    amount: Math.round(payload.plan.amount * 100) / 100, // annual amounts can carry float noise
    currency: payload.plan.currency,
    interval: payload.plan.interval,
    features: payload.features
      .filter((f: any) => f.included)
      .map((f: any) => ({ name: f.name, limit: f.limit })),
  };
}

// A regular plan, by cuprice_plan_id
export async function pricePlan(shareId: string, planId: string, interval: string) {
  const res = await fetch(
    `${CUPRICE}/api/share/${shareId}/checkout-payload?planId=${planId}&billingInterval=${interval}`,
    { cache: "no-store" }
  );
  const { payload } = await res.json();
  if (!payload) throw new Error(`Cuprice plan ${planId} not found`);
  return toPricedPlan(payload);
}

// A custom plan, from selected_features and feature_usage
export async function priceCustomPlan(
  shareId: string,
  names: string[],
  usage: Record<string, number>
) {
  const res = await fetch(`${CUPRICE}/api/share/${shareId}/checkout-payload`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      selectedFeatures: names.map((name) => ({ name })),
      featureUsageAmounts: usage,
      billingInterval: "month",
    }),
    cache: "no-store",
  });
  const { payload } = await res.json();
  if (!payload) throw new Error("Could not price the custom plan");
  return toPricedPlan(payload);
}

import { NextRequest, NextResponse } from "next/server";
import { pricePlan, priceCustomPlan } from "@/lib/cuprice";
import { db } from "@/lib/db";                              // yours
import { createProviderCheckout } from "@/lib/payments";    // yours

export async function GET(req: NextRequest) {
  const q = req.nextUrl.searchParams;
  const shareId = q.get("cuprice_share_id");
  if (!shareId) return NextResponse.json({ error: "Missing cuprice_share_id" }, { status: 400 });

  const plan =
    q.get("cuprice_custom_plan") === "true"
      ? await priceCustomPlan(
          shareId,
          (q.get("selected_features") ?? "").split(",").filter(Boolean),
          JSON.parse(q.get("feature_usage") ?? "{}")
        )
      : await pricePlan(shareId, q.get("cuprice_plan_id")!, q.get("interval") ?? "month");

  // Keep the priced plan on our side; the provider only gets the order ID.
  const order = await db.order.create({
    data: {
      status: "pending",
      cupricePlanId: plan.cupricePlanId,
      planName: plan.name,
      amount: plan.amount,
      currency: plan.currency,
      interval: plan.interval,
      features: plan.features,
    },
  });

  const checkoutUrl = await createProviderCheckout({
    amount: plan.amount,
    currency: plan.currency,
    interval: plan.interval,
    description: plan.name,
    metadata: { orderId: order.id },
    successUrl: "https://yourapp.com/welcome",
    cancelUrl: "https://yourapp.com/pricing",
  });

  return NextResponse.redirect(checkoutUrl);
}

import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db";                             // yours
import { verifyProviderWebhook } from "@/lib/payments";    // yours

export async function POST(req: NextRequest) {
  // Check the signature with your provider's SDK before trusting anything.
  const event = await verifyProviderWebhook(req);
  if (event.type !== "payment.succeeded") return NextResponse.json({ ok: true });

  const order = await db.order.update({
    where: { id: event.metadata.orderId },
    data: { status: "paid" },
  });

  // Copy the plan and its features onto the customer.
  await db.customer.update({
    where: { email: event.customerEmail },
    data: {
      planName: order.planName,
      cupricePlanId: order.cupricePlanId,
      features: order.features,
    },
  });

  return NextResponse.json({ ok: true });
}

import { db } from "@/lib/db";
import type { PlanFeature } from "@/lib/cuprice";

export async function getFeature(email: string, name: string) {
  const customer = await db.customer.findUnique({ where: { email } });
  const features = (customer?.features ?? []) as PlanFeature[];
  return features.find((f) => f.name === name) ?? null;
}

// In a page or route:
// const seats = await getFeature(user.email, "Team seats");
// if (!seats) return <UpgradePrompt />;
// if (seats.limit !== null && teamSize >= seats.limit) return <SeatLimitReached />;

if (order.cupricePlanId > 0) {
  await fetch(`https://app.cuprice.io/api/v1/projects/${process.env.CUPRICE_PROJECT_SLUG}/subscription-events`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.CUPRICE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      event: "subscription.created",
      provider: "your-provider",
      externalId: event.subscriptionId,
      planId: order.cupricePlanId,
      customerEmail: event.customerEmail,
      amount: order.amount,
      currency: order.currency,
      interval: order.interval,
    }),
  });
}