Usage-Based Billing with Stripe in ASP.NET Core: A Practical Guide

Stripe meters aggregate usage for billing: (1) Select meter type (sum, count, last, etc.) based on use case. (2) For token-based billing, 'sum' is best as Stripe sums all events. (3) For request counting, 'count' is appropriate. (4) Define event name (e.g., 'new request'). (5) Create the price and meter, then copy IDs to environment variables.

EF Core RC2 is in final polishing phase before RTM with improvements in JSON support, migrations, and query execution. Jeremy Miller introduces Martin (transactional document DB and event store on PostgreSQL) and Wolverine (event-driven application framework) as part of the Critter Stack. Weasel is a shared migration library supporting PostgreSQL and SQL Server. EF Core migrations face challenges with dynamic multi-tenancy where tenants are added on-the-fly during testing. Good tools should 'just work' with fast startup - developers should get from clean clone to running application quickly. The 'time to login screen' metric measures this. Local development friendliness is crucial for spinning up databases locally for integration testing. Martin integrates with .NET's service collection pattern using Add() for configuration. Documents are stored as JSONB fields in PostgreSQL, supporting any serializable object. Automatic migrations occur on-demand when first entity of a type is accessed, creating tables, indexes, and stored procedures.

This section covers Stripe webhooks and local development setup. Webhooks are essential for keeping application databases synchronized with Stripe events (subscription.created, subscription.updated, subscription.deleted, customer.deleted, customer.updated, payment_method.updated, invoice.payment_action_required, invoice.payment_succeeded). The presenter explains that Stripe sends POST requests to application URLs when events occur. For local development, Stripe CLI is necessary to redirect webhook calls to localhost. The process includes: installing Stripe CLI via Homebrew or downloading executable, running stripe login to authenticate, and running stripe listen --forward-to stripe.test/webhook. The webhook secret must be added to .env as STRIPE_WEBHOOK_SECRET. The presenter demonstrates the complete workflow from Stripe CLI installation to successful webhook listening.

The database schema should include fields to store Stripe integration data: stripeCustomerId (the Stripe Customer ID), stripeSubscriptionId (the Stripe Subscription ID), subscriptionStatus (active, canceled, etc.), and stripePriceId (the Price ID of the current plan). These fields allow the application to track subscription status and sync with Stripe. The schema should be updated via Prisma migrations to add these fields to the User model.

In software development, maintaining synchronization between the database schema and application code is a fundamental challenge. EF Core provides two main approaches: Code-First, where the code is the source of truth and migrations apply changes to the database, and Database-First, where the database schema is the source of truth and reverse engineering generates the corresponding model. The choice between approaches depends on project context—Code-First is recommended for greenfield projects, while Database-First is better for brownfield projects with existing databases.

POST operations are typically not idempotent because they create new resources. However, payment processing requires idempotency to prevent double-charging. Stripe implements this using an 'Idempotency-Key' header. The solution involves: (1) extracting the key from the request header, (2) checking if the key has been processed (using cache or database), (3) if not processed, execute the operation and store the key, (4) if already processed, return the cached result. Keys should have a time-to-live to prevent indefinite storage. The implementation can use transactions to handle concurrent requests safely, ensuring that multiple simultaneous requests with the same key don't cause race conditions.

An idempotent API ensures that making the same request multiple times produces the same result as making it once, which is critical for preventing duplicate transactions in payment systems. The implementation involves generating a unique idempotency key for each request, storing processed keys in a cache (typically with a 24-hour expiration), and checking this cache before processing new requests. When a request arrives, the server first checks if the idempotency key exists in the cache; if it does, the cached response is returned without reprocessing. This approach prevents duplicate charges caused by network failures or client retries while maintaining system reliability and user experience.

This section details how Stripe implements idempotency through client-provided keys. The presenter explains that when a client sends a request with an idempotency key, Stripe checks if that exact request has been processed before. If so, it returns the same response (including status code and body) as the first request, preventing duplicate processing. The presenter contrasts two approaches: returning identical responses including status codes versus returning different status codes (like 409 Conflict). The consistent response pattern provides better client experience because the client code doesn't need to handle different scenarios—it can treat any response as final. The presenter emphasizes that returning the same result, even 500 errors, prevents wasted server resources on redundant attempts.

Payment APIs prevent duplicate transactions by using idempotency keys—unique identifiers attached to each payment request that the backend checks against a database; if the key already exists, the system processes the previous payment attempt instead of creating a new one, ensuring users are only charged once even if they retry failed payments due to network issues or accidental double-clicks.

API Idempotency ensures that calling an API multiple times with identical parameters results in side effects occurring only once. This enables safe client retries without risking double payments. Implementation uses unique 'idempotency keys' sent in request headers. When processing, servers save these keys to databases or caches. Duplicate requests with existing keys are discarded or return previous results. This mechanism is fundamental for building robust payment systems where network failures are inevitable.

This section covers implementing customer self-service portals and production deployment. Enable Stripe's Customer Portal in your dashboard, configure available products, and copy the portal link. Integrate it into your app with pre-filled email parameters for authenticated users. For production, disable test mode, replace API keys, and configure webhook endpoints with your domain. Consider one-time payments ($99 lifetime) as easier to sell than monthly subscriptions ($19). For pre-authentication charging, send login emails via webhook. Custom API integration offers more control for established businesses.

This section covers implementing Stripe Customer Portal for user-managed subscription changes. Key steps include: adding the Stripe Customer Portal plugin with secret key configuration, setting up portal options to enable/disable features like cancellation (with immediate vs. end-of-period settings), creating workflows to generate dynamic customer portal sessions using the user's Stripe customer ID, and configuring return URLs to redirect users back to the dashboard after changes.

Stripe Customer Portal enables customers to self-manage subscriptions through a simple link. The no-code version requires email verification since anyone can access the link. Stripe uses unique Customer IDs (not emails) for each customer, so businesses should maintain one record per customer. Test mode requires real emails for verification. Businesses can customize branding colors and configure what customers can do: pause, upgrade, downgrade, cancel, and switch plans. To integrate, create a page in your website builder and add a link to the Stripe portal URL. The portal requires existing customer records, which are created when customers complete payments. Customers can view their subscription plan, access invoice history and receipts, and manage their subscriptions independently. This self-service capability reduces support tickets and allows customers to make changes without developer intervention.

This section covers the complete implementation of self-service customer portals for subscription management. Key topics include: (1) Setting up Stripe's customer portal for users to manage their own subscriptions, (2) Pre-filling user emails in portal URLs for seamless authentication, (3) Creating Zapier workflows to handle subscription cancellations by updating user status in Airtable. The section also addresses Stripe's fee structure, including the 2.9-3.4% transaction fee and 0.8% subscription setup fee, which merchants should account for in their pricing models.

The Stripe Customer Portal originated for recurring billing subscriptions but is expanding to broader customer management. Key configuration sections include: Invoices (view history, download, pay), Customer Info (customize editable fields like addresses), Payment Methods (add/update supported types), and Subscriptions (cancel, pause, collect reasons, switch plans, update quantities). Merchants configure which products appear as upgrade/downgrade options. Authentication uses email verification, and branding can be customized. Proration settings determine how subscription changes affect charges.