Seats, devices, and sessions.
Sell access for one person or a team, then enforce capacity in the same access checks your app already uses.
Choose limits for each plan#
Open My apps → your app → Seats & devices. The purchaser occupies seat 1. A five-seat plan has space for four additional members. The plan price is the price per paid unit; included seats × purchased quantity determines team capacity, up to 1,000 seats.
| Setting | Meaning |
|---|---|
| Seats per paid unit | 1 for per-seat pricing, or a fixed bundle such as 5 seats. |
| Maximum checkout quantity | 1 keeps a fixed bundle; higher values allow your checkout integration to request more paid units. |
| Registered devices per person | 0 means unlimited. Other values require a stable device ID and limit registered installations. |
| Active sessions per person | 0 means unlimited. Otherwise a session needs an access heartbeat and expires after two minutes without one. |
Buy the right quantity#
Checkout validates quantity against the plan’s maximum. Stripe charges price × quantity and its signed payment/subscription events establish seat quantity. Crypto checkout charges the same numerical USD price × quantity in USDC; the verified transfer establishes quantity. Crypto availability still depends on platform activation. Crypto renewals keep the same quantity while a license is active. Choose a different quantity after expiry; seats do not accumulate. If an older pending checkout with a different quantity settles later, it starts its own paid term instead of extending the previous term. Active Stripe and crypto licenses for the same plan use the larger paid capacity, not the sum.
// Choose the quantity in your own app UI and show price × quantity.
await topPay.openPaymentPage({ profileId: PLAN_ID, quantity: 5 });
// Or use manual-renewal crypto:
await topPay.openCryptoPaymentPage({ profileId: PLAN_ID, quantity: 5 });Web apps send quantity to /api/v1/server/checkout or /api/v1/crypto/checkout from their authenticated backend. Omitting it means one unit. Stripe quantity reductions apply from signed updates; increases unlock after the current invoice is paid (or during an authorized trial); do not start a second subscription to resize an existing team. This release does not provide a TopPay proration editor. Changing a dashboard seat policy changes access rules, not the amount billed.
Invite teammates and remove seats#
The developer can select a paying customer and plan in Seats & devices, then create an invitation or remove a member. Purchasers can do the same through the SDK/API in your app. Pending invitations reserve a seat and expire after seven days. Each code can be claimed once; share it privately. Codes are bearer invitations, not verified-email invitations, and TopPay does not send invitation emails.
const team = await topPay.getSeats({ profileId: PLAN_ID });
const invite = await topPay.createSeatInvite({ profileId: PLAN_ID, label: 'Teammate' });
// Show invite.inviteCode to the purchaser; do not log it.
// The teammate enters this code in your extension:
await topPay.acceptSeatInvite(codeFromYourInviteForm);
await topPay.getUser({ profileId: PLAN_ID });
// Purchaser removes a membership or cancels a pending invitation:
await topPay.removeSeat(seatId, { profileId: PLAN_ID });Seat sharing never bypasses payment or owner controls. The member and purchaser must not be blocked; the purchaser must retain active access; the seat must be within current capacity. Removing the membership revokes inherited access on the next check. A separate personal purchase can still provide access. Members cannot redistribute a purchaser’s seats unless they own a separate eligible license.
For web apps use POST /api/v1/server/seats with your app’s server key and appId, customerId, profileId, action. Supported actions: list, invite (optional label), claim (inviteCode), remove (seatId), revokeDevice (deviceId), releaseSession (sessionId). customerId must come from your verified login; register the customer first through /api/v1/server/customers. Never accept an acting customer ID from untrusted browser input.
Enforce devices and concurrent sessions#
The updated extension SDK sends a persistent random device identifier and uses one shared session per Chrome profile across popup and worker. Background checks can keep that session active while Chrome runs. This counts installations/profiles, not physical hardware or browser tabs. The SDK hashes are not a tamper-proof hardware fingerprint. Reinstalling or clearing local storage can create a new identity; use your own authenticated customer identity for cross-device accounts.
For web apps, send a stable deviceId and the current authenticated session’s sessionId on every protected access check. Use random identifiers of 16–160 letters, digits, underscores or hyphens. Persist device identity separately from session identity. Do not generate a new device ID for every request or reuse one session ID across all devices. Web template auth adapters expose these fields; connect them to your server session.
// Both identity and session come from your authenticated server session.
const result = await fetch('https://toppayext.com/api/v1/server/access', {
method: 'POST',
headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + process.env.TOPPAY_API_KEY },
body: JSON.stringify({ appId: APP_ID, profileId: PLAN_ID,
customerId: session.user.id, deviceId: session.deviceId, sessionId: session.id })
}).then(async response => { if (!response.ok) throw new Error('Access unavailable'); return response.json(); });
if (result.active !== true) throw new Error('Access denied');
// Only now perform the protected action.Check access every 15–60 seconds while active and before protected operations. Session leases last two minutes. Missing required identifiers, revoked devices, full device capacity, or full session capacity return active:false. Inspect entitlement status: device_identity_required, session_identity_required, device_revoked, device_limit, or session_limit. A failed check must lock protected features.
Device lists are available in the dashboard and getSeats(). revokeDevice() blocks that registered device and releases its sessions. The developer can restore it in the dashboard. releaseSession() frees the current session on logout; a later access check can claim it again. Releasing a session is not a permanent ban.
Update an existing integration#
New configured extension downloads include the updated SDK. Existing extensions must ship the new /toppay-sdk.js (or /payframe-extension.js). Add your invitation UI using the methods above; templates are optional and do not automatically add a team-management interface. Web apps must wire their session/device fields before enabling limits. Older integrations without identifiers fail closed once limits are enabled.
Test with separate customer identities: fill all seats, attempt one extra invite, claim the same code twice, remove a member, block the purchaser, expire access, and reach the device/session limits. Then verify that access is denied and restored as expected. No client-only extension can protect executable code against a determined user who modifies it; enforce valuable server-hosted operations on your own backend.
Know what to test and what success looks like before launch.
