Paywall brings plans, feature flags, pricing and payments together. Hand your coding agent one prompt and one scoped token: it integrates the SDK, creates the plans and feature flags, publishes, and tracks every step on one dashboard. Frontend paywalls are coming soon.
{
"sub": "usr_8f21",
"plan": "pro",
"feat": { "exports": 50 },
"exp": 1757000000
}| amara@studio.co | Pro | active | ₹2,400 |
| j.rivera@mail.com | Pro | active | $29.00 |
| kenji@lab.dev | Starter | trialing | — |
| s.okafor@work.io | Pro | refunded | $29.00 |
Your server calls identify once at login and gets a signed entitlement token. From then on it decides what each user may do with a local verify, no network call. Checkout, fulfilment, refunds and revocation all happen inside the hub.
Drop-in pricing tables, paywall modals and upgrade buttons rendered from the same published plans, so the price on screen is always the price at checkout. See what is coming.
Every part of Paywall that an agent needs is machine-readable: a self-contained guide, curl-able SDK files and an admin API scoped to one app by one token. The prompt below is the whole handoff.
Integrate Paywall into this app. Read https://paywallhq.com/integrate.md first and follow it exactly. If this app already integrates Paywall, read https://paywallhq.com/upgrade.md and https://paywallhq.com/changelog.json first. Compare SDK copies with https://paywallhq.com/vendor/manifest.json, preserve local customizations, and follow the relevant feature adoption steps. Context: - Paywall base URL: https://paywallhq.com - App admin token: <paste the at_… token from the app's Overview page> - This app keeps its own auth and users. Paywall only decides what each user is allowed to do and takes the payment. Do this end to end: 1. Fetch the app detail with the token to get the publishable (pk_) and secret (sk_) keys. 2. Create the feature flags this app needs — boolean for on/off, number for limits, text for tier names. 3. Create a free default plan and a paid plan, grant the right features to each, and add a price to the paid plan. 4. Enable the simulated provider so the flow can be tested without real credentials, then publish. 5. Vendor the SDK files, call identify after login, gate features from the entitlement token, and add a checkout call for the upgrade. 6. Track the key steps with hub.track() so the funnel shows up on the Paywall dashboard. 7. Run one upgrade against the simulated provider and show me the result. Never put a payment credential in this app. If any Paywall call returns 401 or 403, stop and ask me for a fresh token.
On the app's Overview page, create an app admin token with the expiry you want. It can read keys and configure this one app, nothing else.
It creates the feature flags, a free plan and a paid plan, grants features, adds prices and publishes. Everything lands in the dashboard as if you had clicked it.
The SDK files are vendored, identify runs after your own login, features are gated from the token and the upgrade button calls checkout.
Checkout created, payment succeeded, refund, decline: the hub emits these itself. The agent adds the client-side steps with one track call, so the funnel is visible from day one.
Your app keeps its own auth and its own users. Paywall answers one question, what is this person allowed to do, and takes the money when the answer should change.
After your own auth succeeds, hand the hub a user id. You get back a signed entitlement token, the plan, and the resolved feature flags.
// after your own auth succeeds
const session = await hub.identify({
userId: user.id,
email: user.email,
});
// { token, plan, status, features, clientToken }Check feature access in your interface or on your server, so each customer gets the features included in their plan.
const exports = useFeature("exports");
if (!exports.enabled) return <Upsell />;
return <ExportButton quota={exports.value} />;One checkout call picks the right provider, currency and price for the customer's country. Then the hub fulfils, refunds and re-issues entitlements on its own.
const { url } = await hub.checkout({
userId: user.id,
planKey: "pro",
successUrl, cancelUrl,
});Create your plans, decide what each customer can use, and track their payments from one dashboard.
Boolean flags, numeric limits and text values, grouped into plans and published as one versioned config.
Your app checks what each customer can use quickly and securely, without contacting Paywall on every request.
Quote the exact price, currency and provider a customer will be charged, resolved by country at checkout time.
Load plans and access quickly, then refresh after checkout so customers can use what they just purchased.
Per-user grants and comps layered over the plan, independent of payments, so a refund never clears a manual grant.
Payments, webhook deliveries and product events in one place, with a per-customer timeline and a payload inspector for every delivery.
A short-lived session opens a hub-hosted portal with the current plan, payment history and upgrade buttons.
Every provider holds both credential sets. Test activity is badged, and test webhooks can never mint a live entitlement.
An app-scoped admin token plus an LLM-ready guide at /integrate.md, so an agent can wire up an app end to end.
Cards and subscriptions where Stripe fits, UPI and India-local rails where it doesn't. Prices can name a provider or stay open and let the hub resolve one at checkout.
Checkout Sessions, refunds and subscription webhooks. Keys verified against the live API from the dashboard.
Payment Links in INR with signature-verified webhooks. The reason this hub exists instead of a hosted competitor.
A built-in provider with a hosted approve/decline page, so a new app can be tested end to end before any account exists.
Consumer apps hold a publishable key and a secret key for their own backend. Provider credentials never leave Paywall.
Every delivery is signature-verified, funnelled through a single fulfilment path, and kept with its full payload.
Apps group under organizations with org-scoped dashboard URLs, while ids and slugs stay globally unique for the API.
The whole catalogue travels as one versioned JSON blob. Never keys, never customer data. Backups and staging twins included.
Create the app, mint one scoped token, and paste the prompt into your coding agent. The hub does the rest, and you watch it happen on the dashboard.