Take your first payment this afternoon.

npm install @payments-lk/node

import { PaymentsLk } from "@payments-lk/node";

const lk = new PaymentsLk(process.env.PAYMENTS_LK_SECRET_KEY); // sk_test_ while you build

app.post("/checkout", async (req, res) => {
  const order = await orders.find(req.body.orderId); // price it from your own records

  const checkout = await lk.checkouts.create(
    {
      amountCents: order.totalCents, // Rs. 1,450.00 is 145000
      description: order.summary,
      reference: order.id,
      successUrl: "https://yourshop.lk/orders/" + order.id,
      cancelUrl: "https://yourshop.lk/cart",
    },
    { idempotencyKey: "order-" + order.id }, // a retry never makes a second checkout
  );

  res.redirect(303, checkout.url);
});

app.post("/webhooks/payments-lk", express.raw({ type: "application/json" }), async (req, res) => {
  let event;
  try {
    event = lk.webhooks.constructEvent(req.body, req.headers["payments-signature"], process.env.PAYMENTS_LK_WEBHOOK_SECRET);
  } catch {
    return res.sendStatus(400); // not signed by Payments.lk
  }

  if (event.type === "payment.succeeded") {
    await orders.markPaid(event.data.reference, event.data.amountCents); // safe to run twice
  }
  res.sendStatus(200);
});

<button data-payments-lk-checkout="/checkout" data-payments-lk-body='{"orderId":"8891"}'>
  Pay Rs. 1,450
</button>
<script src="https://payments.lk/js/pay.js" defer></script>

app.post("/app/checkouts", requireSignedInCustomer, async (req, res) => {
  const order = await orders.forCustomer(req.user.id, req.body.orderId);

  const checkout = await lk.checkouts.create(
    {
      amountCents: order.totalCents,
      description: order.summary,
      reference: order.id,
      successUrl: "myshop://payments-lk/return", // your app's own scheme
      cancelUrl: "myshop://payments-lk/return",
    },
    { idempotencyKey: "order-" + order.id },
  );

  res.json({ id: checkout.id, url: checkout.url });
});

import * as WebBrowser from "expo-web-browser";
import { openCheckout } from "@payments-lk/react-native";

const checkout = await api.post("/app/checkouts", { orderId });
const result = await openCheckout({ checkoutUrl: checkout.url, returnUrl: "myshop://payments-lk/return", browser: WebBrowser });

if (result.status === "succeeded") showConfirming(); // then ask your server

import 'package:payments_lk/payments_lk.dart';

final result = await PaymentsLkCheckout().open(checkoutUrl: created.url, callbackScheme: 'myshop');
if (result.status == CheckoutStatus.succeeded) showConfirming(); // then ask your server

import PaymentsLk

let result = try await PaymentsLkCheckout().present(checkoutURL: created.url, callbackScheme: "myshop")
if result.status == .succeeded { showConfirming() } // then ask your server

private val launcher = CheckoutLauncher(returnScheme = "myshop")

fun pay(checkoutUrl: String) = launcher.launch(this, checkoutUrl)

override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    launcher.handleRedirect(intent)?.let(::show) // then ask your server
}

app.get("/app/orders/:id", requireSignedInCustomer, async (req, res) => {
  const order = await orders.forCustomer(req.user.id, req.params.id);
  // Paid only once your webhook has recorded payment.succeeded, or:
  const checkout = await lk.checkouts.retrieve(order.checkoutId);
  res.json({ paid: checkout.payment.status === "succeeded" });
});

const checkout = await lk.checkouts.create({
  amountCents: 250000,
  description: "First month of your coffee subscription",
  reference: "sub-" + customer.id,
  customer: { name: customer.name, email: customer.email },
  saveCard: true, // the checkout asks the customer if they want to keep the card
  successUrl: "https://yourshop.lk/account",
  cancelUrl: "https://yourshop.lk/account",
});

if (event.type === "card.saved") {
  // event.data is the saved card:
  //   { id: "card_...", customerEmail, scheme, last4, mode, active,
  //     expiry: { month, year },      // when the card itself runs out
  //     paymentId,                    // the payment the customer made when they kept it
  //     consent: { agreedAt, locale, wording } }  // what they agreed to
  await customers.rememberCard(event.data.customerEmail, event.data.id);
}
if (event.type === "card.save_failed") {
  // The payment went through, but the card was not kept. event.data is the payment (cardSave: "failed").
  await customers.askToSaveCardAgain(event.data.customer?.email);
}

const payment = await lk.cards.charge(
  customer.cardId,
  { amountCents: 250000, description: "October coffee subscription", reference: "sub-" + customer.id + "-2026-10" },
  { idempotencyKey: "sub-" + customer.id + "-2026-10" }, // one charge per billing period, however often you retry
);
// Live charges answer by webhook: wait for payment.succeeded or payment.failed.

await lk.cards.delete(customer.cardId);  // when the customer removes it or cancels

// One page of a customer's cards, or every one of them.
const page = await lk.cards.list({ customerEmail: customer.email, limit: 25 });
for await (const card of lk.cards.listAll({ customerEmail: customer.email })) {
  if (card.expiry) console.log(card.id, card.scheme, card.last4, card.expiry.month + "/" + card.expiry.year);
}

// A card you deleted still reads, so you can say why a charge stopped.
const gone = await lk.cards.retrieve(customer.cardId);  // gone.retiredAt, gone.consent

// Once, from a script or on the dashboard's Subscriptions page. Keep the ids in your config.
const monthly = await lk.prices.create({ product: { name: "Coffee club" }, unitAmountCents: 250000, interval: "month" });
const yearly = await lk.prices.create({ productId: monthly.product.id, unitAmountCents: 2500000, interval: "year" });

app.post("/subscribe", requireSignedInCustomer, async (req, res) => {
  const member = await members.find(req.user.id);
  if (member.subscriptionId) return res.status(409).json({ message: "You are already in the club." });

  // Found by email if you made them before, made otherwise.
  const customer = await lk.customers.create({ email: req.user.email, name: req.user.name });
  const subscription = await lk.subscriptions.create(
    {
      customerId: customer.id,
      priceId: req.body.plan === "yearly" ? config.yearlyPriceId : config.monthlyPriceId,
      successUrl: "https://yourshop.lk/account",
      cancelUrl: "https://yourshop.lk/club",
    },
    { idempotencyKey: "club-" + req.user.id }, // a double click never starts two
  );
  await members.remember(req.user.id, customer.id, subscription.id);

  // A customer with a card already on file is charged at once, with nowhere to send them.
  if (!subscription.checkoutUrl) return res.status(409).json({ message: "You are subscribed. See your account." });
  res.json({ url: subscription.checkoutUrl });
});

<button data-payments-lk-checkout="/subscribe" data-payments-lk-body='{"plan":"monthly"}'>
  Join the club, Rs. 2,500 a month
</button>
<button data-payments-lk-checkout="/subscribe" data-payments-lk-body='{"plan":"yearly"}'>
  Or Rs. 25,000 a year
</button>
<p id="club-error" role="alert"></p>
<script src="https://payments.lk/js/pay.js" defer></script>

// Monthly and yearly side by side, a 14 day trial, and a box for coupon codes.
const link = await lk.subscriptionLinks.create({
  name: "Join the coffee club",
  priceIds: [config.monthlyPriceId, config.yearlyPriceId],
  trialDays: 14,
  allowPromotionCodes: true,
  successUrl: "https://yourshop.lk/welcome",
});
// link.url is https://payments.lk/s/...: put it on a page, in an email or behind a QR code.

<!-- The link's whole plan chooser, on your page, sized to fit -->
<div data-payments-lk-plans="LINKCODE"></div>

<!-- Or a button that opens the link with one plan chosen first -->
<button data-payments-lk-subscribe="LINKCODE" data-payments-lk-plan="price_0123456789abcdefghij">Join the club</button>

<script src="https://payments.lk/js/pay.js" defer></script>

switch (event.type) {
  case "customer.subscription.created":
  case "customer.subscription.updated":
  case "customer.subscription.deleted":
    // event.data is the subscription: status is trialing, active, past_due, unpaid, paused or canceled.
    await members.syncStatus(event.data.customerId, event.data.id, event.data.status, event.data.currentPeriodEnd);
    break;
  case "invoice.paid":
    await receipts.record(event.data.customerId, event.data.number, event.data.amountPaidCents);
    break;
  case "invoice.payment_failed":
    // We retry on days 1, 3, 7 and 14 and email the customer a page to pay with a new card.
    await members.flagPaymentProblem(event.data.customerId);
    break;
  case "entitlements.active_entitlement_summary.updated":
    // Every feature the customer has now, whenever that changes.
    await members.setFeatures(event.data.customerId, event.data.entitlements.map((e) => e.lookupKey));
    break;
}

// The portal's address is on payments.lk, so the same pay button opens it.
app.post("/manage-subscription", requireSignedInCustomer, async (req, res) => {
  const member = await members.find(req.user.id);
  const session = await lk.billingPortal.sessions.create({ customerId: member.customerId, returnUrl: "https://yourshop.lk/account" });
  res.json({ url: session.url }); // it works for an hour: make a new one each time
});

// Sandbox only: run a test subscription 31 days ahead and watch the renewal happen.
await lk.testClocks.advance({ subscriptionId: subscription.id, seconds: 31 * 86400 });
const next = await lk.invoices.upcoming({ subscriptionId: subscription.id });