Schematic decouples billing state from code and enforces pricing at runtime. Manage entitlements, usage, and plans directly from Stripe.
Trusted in production by:


Webhook handlers, entitlement caches, usage sync — all replaced by clean interfaces. Complex packaging, simple code.
1// 1. Listen for subscription changes
2app.post('/webhooks/stripe', async (req, res) => {
3 const event = stripe.webhooks.constructEvent(
4 req.body, sig, secret
5 );
6
7 if (event.type === 'customer.subscription.updated') {
8 const sub = event.data.object;
9 const plan = await db.plans.findByStripePriceId(
10 sub.items[0].price.id
11 );
12 await db.entitlements.upsert({
13 customerId: sub.customer,
14 planId: plan.id,
15 features: plan.features,
16 limits: plan.limits,
17 });
18 await redis.del(`entitlements:${sub.customer}`);
19 }
20});
21
22// 2. Check entitlements on every request
23async function checkAccess(customerId, feature) {
24 let ent = await redis.get(
25 `entitlements:${customerId}`
26 );
27 if (!ent) {
28 ent = await db.entitlements.findByCustomer(
29 customerId
30 );
31 await redis.set(
32 `entitlements:${customerId}`, ent, 'EX', 300
33 );
34 }
35 const limit = ent.limits[feature];
36 const usage = await db.usage.count({
37 customerId, feature, period: 'month'
38 });
39 return usage < limit;
40}
41
42// 3. Track usage and sync to Stripe
43async function trackUsage(customerId, feature) {
44 await db.usage.insert({
45 customerId, feature, timestamp: Date.now()
46 });
47 const meterId = await db.meters.findByFeature(
48 feature
49 );
50 await stripe.billing.meterEvents.create({
51 event_name: meterId,
52 payload: {
53 stripe_customer_id: customerId,
54 value: '1',
55 },
56 });
57}
58
59// 4. Handle overrides, trials, custom plans...
60// (another 200 lines)1import { SchematicClient } from
2 "@schematichq/schematic-typescript-node";
3
4const client = new SchematicClient({ apiKey });
5
6// Check access
7const hasAccess = await client.checkFlag(
8 { company: { id: "acme-corp" } },
9 "api-calls"
10);
11
12// Track usage
13client.track({
14 event: "api-call",
15 company: { id: "acme-corp" },
16});
17
18// Schematic handles the rest:
19// webhooks, caching, usage aggregation,
20// Stripe sync, overrides, trialsStripe is the billing infrastructure. Schematic is the layer that turns billing state into application behavior. You write two calls instead of two hundred lines.
Everything you need to turn Stripe billing into real-time access control, usage enforcement, and customer lifecycle management.
Decouple pricing and billing logic from your codebase. Change plans, limits, and pricing models without deploying code.

Usage-based, credits, overages, seats, flat-rate, or hybrid. Launch and iterate on any model Stripe supports without rebuilding your billing integration.

Manage overrides and custom plans for sales-led deals. Bump limits, grant features, set expiration dates, leave notes for context. Use overrides to get customers over the line.

Version your plans and bulk-migrate customers between them. Grandfather legacy pricing without maintaining parallel code paths.
Power paywalls, usage counters, and limit alerts. Surface upgrade paths in your product with drop-in billing components.

Know who's overusing, underpaying, and ready to expand. Map usage to revenue opportunities and spot upgrade triggers automatically. Surface monetization opportunities with a unified view of billing and usage data.

The only entitlements platform with a native Stripe App. Set up in minutes, manage everything from the dashboard you already use.
Connect your Stripe account in one click. Import your products, prices, subscriptions, and customers. Bidirectional sync keeps everything up to date automatically.

Define plans, entitlements, usage-based limits, and credits in Schematic. Map them to your Stripe products. Implement the SDK to enforce access in your application.

Grant beta features, bump limits, set expiration dates, and leave notes — all without leaving the Stripe dashboard. Your sales and support teams already live in Stripe.

Real-time visibility into how every customer uses features against their plan limits. Spot overages, underuse, and expansion opportunities at a glance.

Stripe owns billing. Schematic owns what customers can do. Everything syncs automatically — no integration glue required.
Entitlement state is pushed to your app via WebSocket. Flag checks evaluate locally with no network dependency on the hot path.
Schematic streams entitlement state to your application via WebSocket. Flag checks evaluate locally with no network dependency on the hot path.
One API to enforce access and automate provisioning across hybrid pricing models, multi-product offerings, and multiple GTM motions.
Built for teams that need uptime guarantees, compliance, and full visibility into every flag check and API call.
“Using Schematic means our engineers can focus on building product features rather than maintaining billing logic.”
“What used to take months now takes weeks or days.”
“Doing it right is not a core competency of our business, nor should it be.”
Install the Stripe App or talk to the team. Either way, you’re up and running fast.
Sync your Stripe products, prices, and meters. Configure entitlements in minutes.
Not sure how Schematic fits your stack? Walk through it with the team.
Pick a time with the Schematic team. 30 minutes, straight to your questions.