Stripe Production Engineering

Provides best practices and code patterns for building, scaling, and operating production Stripe payment systems from checkout to enterprise billing.

Audits

Pass

ClawScanPass

Agentic behavior and permission review.

Static analysisPass

Pattern checks against bundled files.

VirusTotalPass

Multi-engine malware detections and file reputation.

Install

openclaw skills install afrexai-stripe-production

Stripe Production Engineering

Complete methodology for building, scaling, and operating production Stripe payment systems. From first checkout to enterprise billing at scale.

Quick Health Check

Run through these 8 signals. Score 1 point each. Below 5 = stop and fix.

✅ Webhook endpoint verified and idempotent
✅ All API calls use idempotency keys
✅ Customer portal enabled for self-service
✅ Stripe Tax or manual tax collection configured
✅ Failed payment retry logic with dunning emails
✅ PCI compliance questionnaire completed (SAQ-A minimum)
✅ Test mode → live mode checklist completed
✅ Monitoring/alerting on payment failures and webhook errors

Score: /8 — Below 5? Fix gaps before adding features.

Phase 1: Architecture Strategy

Integration Pattern Decision

Pattern	Best For	Complexity	PCI Scope
Stripe Checkout (hosted)	MVPs, quick launch	Low	SAQ-A (minimal)
Payment Element (embedded)	Custom UX, brand control	Medium	SAQ-A
Card Element (legacy)	Existing integrations	Medium	SAQ-A-EP
Direct API	Platform/marketplace	High	SAQ-D (avoid)

Decision rule: Start with Checkout. Move to Payment Element only when you have specific UX requirements that Checkout can't solve.

Billing Model Selection

Model	Stripe Product	Use When
One-time	Payment Links / Checkout	Single purchases, lifetime deals
Recurring flat	Subscriptions	Fixed monthly/annual SaaS
Usage-based	Metered billing	API calls, compute, storage
Per-seat	Subscriptions + quantity	Team/user-based pricing
Tiered	Tiered pricing	Volume discounts
Hybrid	Subscription + usage records	Base fee + overage

Project Structure

src/
  payments/
    stripe.config.ts        # Stripe client initialization
    webhooks.handler.ts     # Webhook endpoint + event routing
    checkout.service.ts     # Checkout session creation
    subscription.service.ts # Subscription lifecycle
    customer.service.ts     # Customer CRUD + portal
    invoice.service.ts      # Invoice customization
    tax.service.ts          # Tax calculation
    types.ts                # Shared types
  middleware/
    webhook-verify.ts       # Signature verification middleware

7 Architecture Rules

Never trust the client — verify payment status server-side via webhooks, never from redirect URLs
Webhooks are the source of truth — your database updates from webhook events, not API call responses
Idempotency everywhere — every mutating API call gets an idempotency key
One Stripe customer per user — create customer at signup, store stripe_customer_id in your DB
Metadata is your friend — attach user_id, plan, source to every object for debugging
Test mode mirrors live — your test environment should use the exact same code paths
Never store card numbers — use Stripe.js/Elements, never handle raw card data

Phase 2: Core Integration Patterns

Stripe Client Setup

// stripe.config.ts
import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
  apiVersion: '2024-12-18.acacia',  // Pin API version!
  maxNetworkRetries: 2,
  timeout: 10_000,
  telemetry: false,
});

export { stripe };

Rules:

Pin API version — never use rolling latest
Set explicit timeout (10s default is fine)
Disable telemetry in production if privacy-sensitive
Use restricted keys with minimum required permissions

Customer Lifecycle

// customer.service.ts
async function getOrCreateCustomer(userId: string, email: string, name?: string) {
  // Check DB first
  const existing = await db.users.findOne({ id: userId });
  if (existing?.stripeCustomerId) {
    return existing.stripeCustomerId;
  }

  // Create in Stripe
  const customer = await stripe.customers.create({
    email,
    name,
    metadata: {
      user_id: userId,
      created_via: 'signup',
    },
  });

  // Store mapping
  await db.users.update({ id: userId }, { stripeCustomerId: customer.id });
  return customer.id;
}

Customer rules:

Create at signup, not at first purchase
Always set metadata.user_id for reverse lookups
Store stripe_customer_id in your users table
Use customer email updates to sync — listen for customer.updated

Checkout Session (Recommended Starting Point)

// checkout.service.ts
async function createCheckoutSession(params: {
  customerId: string;
  priceId: string;
  mode: 'payment' | 'subscription';
  successUrl: string;
  cancelUrl: string;
  metadata?: Record<string, string>;
}) {
  const session = await stripe.checkout.sessions.create({
    customer: params.customerId,
    mode: params.mode,
    line_items: [{ price: params.priceId, quantity: 1 }],
    success_url: `${params.successUrl}?session_id={CHECKOUT_SESSION_ID}`,
    cancel_url: params.cancelUrl,
    metadata: params.metadata ?? {},

    // Recommended defaults
    allow_promotion_codes: true,
    billing_address_collection: 'auto',
    tax_id_collection: { enabled: true },
    customer_update: { address: 'auto', name: 'auto' },
    payment_method_types: ['card'],
    
    // For subscriptions
    ...(params.mode === 'subscription' && {
      subscription_data: {
        metadata: params.metadata ?? {},
        trial_period_days: 14,
      },
    }),
  }, {
    idempotencyKey: `checkout_${params.customerId}_${params.priceId}_${Date.now()}`,
  });

  return session;
}

Payment Element (Custom UI)

// Server: create PaymentIntent
async function createPaymentIntent(params: {
  customerId: string;
  amount: number;      // in cents!
  currency: string;
  metadata?: Record<string, string>;
}) {
  return stripe.paymentIntents.create({
    customer: params.customerId,
    amount: params.amount,
    currency: params.currency,
    automatic_payment_methods: { enabled: true },
    metadata: {
      ...params.metadata,
      created_at: new Date().toISOString(),
    },
  }, {
    idempotencyKey: `pi_${params.customerId}_${params.amount}_${Date.now()}`,
  });
}

// Client: React Payment Element
// <PaymentElement /> handles all payment method rendering
// Use confirmPayment() on form submit

Phase 3: Subscription Management

Subscription Lifecycle Events

Created → Active → Past Due → Canceled → (optionally) Unpaid
                ↓
            Trialing → Active
                ↓
            Paused → Resumed → Active

Critical Webhook Events for Subscriptions

Event	Action
`customer.subscription.created`	Provision access, set plan in DB
`customer.subscription.updated`	Handle plan changes, quantity updates
`customer.subscription.deleted`	Revoke access, clean up
`customer.subscription.trial_will_end`	Send conversion email (3 days before)
`invoice.payment_succeeded`	Confirm access renewal
`invoice.payment_failed`	Start dunning sequence
`customer.subscription.paused`	Restrict access, retain data
`customer.subscription.resumed`	Restore access

Plan Change Patterns

// Upgrade (immediate)
async function upgradePlan(subscriptionId: string, newPriceId: string) {
  const sub = await stripe.subscriptions.retrieve(subscriptionId);
  return stripe.subscriptions.update(subscriptionId, {
    items: [{
      id: sub.items.data[0].id,
      price: newPriceId,
    }],
    proration_behavior: 'create_prorations',  // charge difference immediately
    payment_behavior: 'error_if_incomplete',
  });
}

// Downgrade (at period end)
async function downgradePlan(subscriptionId: string, newPriceId: string) {
  const sub = await stripe.subscriptions.retrieve(subscriptionId);
  return stripe.subscriptions.update(subscriptionId, {
    items: [{
      id: sub.items.data[0].id,
      price: newPriceId,
    }],
    proration_behavior: 'none',               // no refund, change at renewal
    billing_cycle_anchor: 'unchanged',
  });
}

// Cancel (at period end — always prefer this)
async function cancelSubscription(subscriptionId: string) {
  return stripe.subscriptions.update(subscriptionId, {
    cancel_at_period_end: true,
  });
  // User keeps access until period ends
  // Handle `customer.subscription.deleted` to revoke
}

Dunning (Failed Payment Recovery)

# Stripe Dashboard → Settings → Subscriptions → Smart Retries
retry_schedule:
  attempt_1: 1 day after failure    # Smart timing
  attempt_2: 3 days after failure
  attempt_3: 5 days after failure
  attempt_4: 7 days after failure   # Final attempt

# Custom dunning emails (supplement Stripe's built-in)
dunning_sequence:
  - day: 0
    action: "Email: payment failed, update card link"
    template: "Your payment of {amount} failed. Update → {portal_url}"
  - day: 3
    action: "Email: second notice, urgency"
    template: "Still unable to charge. Update payment to avoid interruption."
  - day: 5
    action: "Email: final warning"
    template: "Last chance to update. Access pauses in 48 hours."
  - day: 7
    action: "Pause or cancel subscription"
    note: "Automatic via Stripe if all retries fail"

Usage-Based Billing

// Report usage for metered billing
async function reportUsage(subscriptionItemId: string, quantity: number) {
  return stripe.subscriptionItems.createUsageRecord(subscriptionItemId, {
    quantity,
    timestamp: Math.floor(Date.now() / 1000),
    action: 'increment',  // or 'set' for absolute value
  }, {
    idempotencyKey: `usage_${subscriptionItemId}_${Date.now()}`,
  });
}

// Best practice: batch usage reports
// Don't report every API call individually — aggregate per hour/day
// Report at least daily to avoid surprise bills at period end

Phase 4: Webhooks (The Most Critical Part)

Webhook Handler Template

// webhooks.handler.ts
import { stripe } from './stripe.config';
import type { Request, Response } from 'express';

const WEBHOOK_SECRET = process.env.STRIPE_WEBHOOK_SECRET!;

// Event handlers map
const handlers: Record<string, (event: Stripe.Event) => Promise<void>> = {
  'checkout.session.completed': handleCheckoutCompleted,
  'customer.subscription.created': handleSubscriptionCreated,
  'customer.subscription.updated': handleSubscriptionUpdated,
  'customer.subscription.deleted': handleSubscriptionDeleted,
  'invoice.payment_succeeded': handleInvoicePaymentSucceeded,
  'invoice.payment_failed': handleInvoicePaymentFailed,
  'customer.subscription.trial_will_end': handleTrialEnding,
  'payment_intent.succeeded': handlePaymentSucceeded,
  'payment_intent.payment_failed': handlePaymentFailed,
};

export async function handleWebhook(req: Request, res: Response) {
  // 1. Verify signature (NEVER skip this)
  let event: Stripe.Event;
  try {
    event = stripe.webhooks.constructEvent(
      req.body,        // raw body, not parsed JSON!
      req.headers['stripe-signature']!,
      WEBHOOK_SECRET,
    );
  } catch (err) {
    console.error('Webhook signature verification failed:', err);
    return res.status(400).send('Invalid signature');
  }

  // 2. Idempotency check
  const alreadyProcessed = await db.webhookEvents.findOne({ eventId: event.id });
  if (alreadyProcessed) {
    return res.status(200).json({ received: true, duplicate: true });
  }

  // 3. Route to handler
  const handler = handlers[event.type];
  if (handler) {
    try {
      await handler(event);
      await db.webhookEvents.insert({ eventId: event.id, type: event.type, processedAt: new Date() });
    } catch (err) {
      console.error(`Webhook handler failed for ${event.type}:`, err);
      return res.status(500).send('Handler error');  // Stripe will retry
    }
  }

  // 4. Always return 200 quickly
  res.status(200).json({ received: true });
}

10 Webhook Rules

Verify every signature — never process unverified events
Use raw body — don't parse JSON before verification (Express: express.raw({type: 'application/json'}))
Idempotency — store processed event IDs, handle duplicates gracefully
Return 200 fast — do heavy processing async/in background
Handle out-of-order — events may arrive in unexpected order; check current state before applying
Don't rely on event data alone — for critical actions, re-fetch the object from the API
Log everything — event ID, type, relevant object IDs, processing result
Monitor failures — alert on repeated 500s or unhandled event types
Use CLI for local dev — stripe listen --forward-to localhost:3000/webhooks
Register only events you handle — don't subscribe to everything

Essential Events by Use Case

Use Case	Must-Have Events
One-time payments	`checkout.session.completed`, `payment_intent.succeeded`, `payment_intent.payment_failed`
Subscriptions	All subscription.* + `invoice.payment_succeeded`, `invoice.payment_failed`, `invoice.upcoming`
Marketplace/Connect	`account.updated`, `payout.paid`, `payout.failed`, `transfer.created`
Invoicing	`invoice.created`, `invoice.finalized`, `invoice.paid`, `invoice.payment_failed`

Phase 5: Customer Portal & Self-Service

// Customer portal — saves you building billing UI
async function createPortalSession(customerId: string, returnUrl: string) {
  return stripe.billingPortal.sessions.create({
    customer: customerId,
    return_url: returnUrl,
  });
}

// Configure in Dashboard → Settings → Customer portal
// Enable: Update payment method, Cancel subscription, View invoices
// Optional: Plan switching, Invoice history download

Portal Configuration Checklist

Payment method update enabled
Subscription cancellation with reason collection
Plan switching with proration preview
Invoice history visible
Business information (name, logo) set
Return URL configured
Terms of service / privacy policy linked

Phase 6: Tax Collection

Tax Decision Tree

Do you sell to EU customers?
  YES → Need VAT collection
    Use Stripe Tax (automatic) OR manual tax rates
  NO → 
Do you sell to US customers in multiple states?
  YES → Need sales tax (nexus rules)
    Use Stripe Tax (automatic) — manual is nightmare
  NO →
Do you exceed $100K revenue or 200 transactions in any US state?
  YES → You have economic nexus — collect tax
  NO → May not need to collect, but verify with accountant

Stripe Tax Setup

// Enable automatic tax on Checkout
const session = await stripe.checkout.sessions.create({
  // ... other config
  automatic_tax: { enabled: true },
  customer_update: { address: 'auto' },  // Required for tax calculation
});

// For subscriptions via API
const subscription = await stripe.subscriptions.create({
  customer: customerId,
  items: [{ price: priceId }],
  automatic_tax: { enabled: true },
});

Tax rules:

Stripe Tax handles calculation + collection automatically
You still need to file/remit taxes yourself (or use Stripe Tax filing in supported regions)
Always collect billing address for accurate tax calculation
Enable tax ID collection for B2B reverse charge (EU)

Phase 7: Stripe Connect (Marketplaces & Platforms)

Connect Account Types

Type	Control	Onboarding	Best For
Standard	Low (Stripe-hosted dashboard)	Stripe-hosted	Marketplaces where sellers manage their own Stripe
Express	Medium (limited dashboard)	Stripe-hosted	Platforms managing payouts for contractors/sellers
Custom	Full (you build everything)	You build it	Enterprise platforms needing total control

Decision rule: Use Express unless you have a specific reason not to.

Payment Flow Patterns

// Direct charge (platform takes cut)
const paymentIntent = await stripe.paymentIntents.create({
  amount: 10000,  // $100
  currency: 'usd',
  application_fee_amount: 1500,  // $15 platform fee
  transfer_data: {
    destination: 'acct_seller123',
  },
});

// Destination charge (seller's Stripe processes)
// Same as above but payment appears on seller's statement

// Separate charges and transfers (most flexible)
const charge = await stripe.paymentIntents.create({
  amount: 10000,
  currency: 'usd',
});
// Then transfer to seller
const transfer = await stripe.transfers.create({
  amount: 8500,
  currency: 'usd',
  destination: 'acct_seller123',
  transfer_group: 'order_123',
});

Phase 8: Testing Strategy

Test Mode Checklist

Test	How	Pass Criteria
Successful payment	Card: 4242424242424242	Checkout completes, webhook fires, DB updated
Declined card	Card: 4000000000000002	Error shown, no DB change
3D Secure required	Card: 4000002500003155	Auth modal shown, completes after
Insufficient funds	Card: 4000000000009995	Graceful failure message
Subscription create	Use test price, complete checkout	Sub active, access granted
Payment failure + retry	Attach 4000000000000341, trigger invoice	Dunning sequence fires
Webhook replay	`stripe events resend evt_xxx`	Idempotent — no duplicate processing
Refund	Refund via API or Dashboard	Customer notified, access handled
Upgrade/downgrade	Change plan mid-cycle	Proration correct
Cancel at period end	Cancel, verify access until period end	Access maintained, then revoked

Stripe CLI for Local Development

# Install
brew install stripe/stripe-cli/stripe

# Login
stripe login

# Forward webhooks to local server
stripe listen --forward-to localhost:3000/api/webhooks/stripe

# Trigger specific events for testing
stripe trigger checkout.session.completed
stripe trigger invoice.payment_failed
stripe trigger customer.subscription.deleted

Phase 9: Security & PCI Compliance

PCI Compliance Levels

Level	Criteria	Requirement
SAQ-A	Checkout or Elements (recommended)	Annual questionnaire, no scan
SAQ-A-EP	Client-side tokenization	Annual questionnaire + quarterly scan
SAQ-D	Direct API card handling (avoid)	Full audit, quarterly scans, penetration tests

Security Checklist (P0 — Mandatory)

API keys in environment variables, never in code
Webhook signatures verified on every request
Restricted API keys with minimum permissions
HTTPS everywhere (Stripe requires it)
No card numbers logged, stored, or transmitted
CSRF protection on payment endpoints
Rate limiting on checkout creation
Idempotency keys on all mutating calls

API Key Strategy

Live mode:
  sk_live_xxx    → Server only, env var, restricted permissions
  pk_live_xxx    → Client-side (public, safe to expose)
  whsec_xxx      → Webhook secret, server only

Test mode:
  sk_test_xxx    → Same restrictions as live
  pk_test_xxx    → Client-side
  whsec_test_xxx → Webhook secret (different from live!)

Restricted key permissions (create in Dashboard → API Keys):

Checkout Sessions: Write
Customers: Write
Subscriptions: Read/Write
Webhook Endpoints: Read
Everything else: None

Phase 10: Go-Live Checklist

Pre-Launch (P0 — Mandatory)

Webhook endpoint registered and verified in live mode
All webhook events subscribed (same as test)
Live API keys in production environment
Customer portal configured with live branding
Test a real $1 payment end-to-end (then refund)
Error handling for all payment states (success, failure, pending, requires_action)
Logging: payment ID, customer ID, amount, status on every transaction
PCI SAQ-A completed in Stripe Dashboard

Pre-Launch (P1 — Within First Week)

Monitoring: alert on payment failure rate > 5%
Monitoring: alert on webhook delivery failures
Receipt emails configured (Stripe auto-sends or custom)
Refund process documented
Dispute/chargeback response process
Dunning emails active for subscriptions
Stripe Tax enabled (if applicable)

Pre-Launch (P2 — Within First Month)

Revenue analytics dashboard
MRR/churn tracking
Coupon/promotion code strategy
Annual vs monthly pricing toggle
Customer portal self-service verified

Phase 11: Monitoring & Operations

Key Metrics Dashboard

metrics:
  payment_success_rate:
    calculation: "successful_payments / total_attempts × 100"
    healthy: ">= 95%"
    warning: "90-95%"
    critical: "< 90%"
    
  webhook_delivery_rate:
    calculation: "successful_deliveries / total_events × 100"  
    healthy: ">= 99.5%"
    critical: "< 99%"
    
  average_revenue_per_user:
    calculation: "total_revenue / active_customers"
    track: "weekly trend"
    
  monthly_recurring_revenue:
    calculation: "sum(active_subscription_amounts)"
    track: "monthly growth rate"
    
  churn_rate:
    calculation: "canceled_subscriptions / total_active × 100"
    healthy: "< 5% monthly"
    warning: "5-10%"
    critical: "> 10%"
    
  involuntary_churn:
    calculation: "failed_payment_cancellations / total_churn × 100"
    note: "Should be < 30% of total churn — fix with better dunning"

Weekly Review Checklist

Payment success rate vs last week
Failed payments — any patterns? (card type, region, amount)
Webhook failures — any endpoints timing out?
New disputes/chargebacks — respond within 7 days
Subscription metrics: new, churned, upgraded, downgraded
Revenue: MRR, net new MRR, expansion MRR, contraction MRR

Phase 12: Advanced Patterns

Pricing Page with Annual Toggle

// Create both monthly and annual prices for each plan
const prices = {
  starter: {
    monthly: 'price_starter_monthly',   // $29/mo
    annual: 'price_starter_annual',     // $290/yr (save ~17%)
  },
  pro: {
    monthly: 'price_pro_monthly',       // $79/mo
    annual: 'price_pro_annual',         // $790/yr
  },
};

// Client toggles monthly/annual → creates checkout with correct priceId

Grandfathering & Price Increases

// New price, existing customers keep old price
// 1. Create new price object (don't modify existing)
// 2. New signups use new price
// 3. Existing subs stay on old price until they change plans
// 4. Optional: scheduled price migration with notice

async function schedulePriceIncrease(subscriptionId: string, newPriceId: string, effectiveDate: Date) {
  // Create a subscription schedule
  const schedule = await stripe.subscriptionSchedules.create({
    from_subscription: subscriptionId,
  });
  
  // Add phase with new price
  await stripe.subscriptionSchedules.update(schedule.id, {
    phases: [
      { items: [{ price: currentPriceId }], end_date: Math.floor(effectiveDate.getTime() / 1000) },
      { items: [{ price: newPriceId }] },
    ],
  });
}

Coupon & Promotion Codes

// Create coupon (reusable)
const coupon = await stripe.coupons.create({
  percent_off: 20,
  duration: 'repeating',
  duration_in_months: 3,
  max_redemptions: 100,
  metadata: { campaign: 'launch_2024' },
});

// Create promotion code (shareable link)
const promoCode = await stripe.promotionCodes.create({
  coupon: coupon.id,
  code: 'LAUNCH20',
  max_redemptions: 50,
  expires_at: Math.floor(new Date('2024-12-31').getTime() / 1000),
});

Handling Disputes (Chargebacks)

dispute_response_process:
  when_received:
    - Log dispute details: amount, reason, deadline
    - Alert team immediately
    - Begin evidence collection within 24 hours
    
  evidence_to_collect:
    - Customer communication (emails, chat logs)
    - Delivery proof (access logs, download records)
    - Terms of service acceptance timestamp
    - Refund policy shown at checkout
    - IP address and device fingerprint
    - Prior successful transactions from same customer
    
  submit:
    - Within 7 days (Stripe deadline is usually 21 days, but act fast)
    - Use Stripe Dashboard evidence submission form
    - Include written rebuttal addressing specific reason code
    
  prevention:
    - Clear billing descriptor (customer recognizes charge)
    - Send receipt emails immediately
    - Offer easy refunds before disputes escalate
    - Use Radar for fraud detection

10 Common Mistakes

#	Mistake	Fix
1	Trusting client-side redirect as payment confirmation	Always verify via webhook
2	Parsing JSON body before webhook signature verification	Use raw body buffer
3	No idempotency keys on API calls	Add to every mutating call
4	Immediately canceling instead of cancel_at_period_end	Always cancel at period end unless refunding
5	Amounts in dollars instead of cents	Stripe uses smallest currency unit (cents)
6	Not handling 3D Secure / requires_action status	Check payment_intent.status, handle authentication
7	Same webhook secret for test and live	Use separate secrets per environment
8	Not testing with Stripe CLI locally	Set up `stripe listen` in development
9	Hardcoding price IDs	Use config/env vars, different per environment
10	No dunning strategy for failed subscription payments	Configure Smart Retries + custom emails

Quality Rubric (0-100)

Dimension	Weight	Criteria
Webhook reliability	25%	Signature verification, idempotency, error handling, event coverage
Security & PCI	20%	SAQ-A compliance, key management, no card data exposure
Subscription lifecycle	15%	Create/upgrade/downgrade/cancel/pause all handled correctly
Customer experience	15%	Portal, receipts, dunning emails, clear error messages
Testing coverage	10%	All payment states tested, CLI setup, edge cases
Monitoring	10%	Failure alerts, revenue metrics, dispute tracking
Code quality	5%	TypeScript types, error handling, idempotency keys, logging

Commands

The agent responds to these natural language requests:

"Set up Stripe checkout" → Full Checkout integration with webhook handler
"Add subscriptions" → Subscription lifecycle with plan changes and dunning
"Configure webhooks" → Webhook handler with signature verification and idempotency
"Set up customer portal" → Billing portal configuration
"Add usage-based billing" → Metered subscription with usage reporting
"Stripe security audit" → PCI compliance check + security hardening
"Go-live checklist" → Pre-launch verification for production
"Set up Stripe Connect" → Marketplace/platform payment flows
"Add coupons and promos" → Promotion code system
"Review payment metrics" → Revenue and payment health dashboard
"Handle a dispute" → Chargeback response process
"Migrate pricing" → Grandfathering and price increase strategy