We’re rolling out a set of powerful enhancements to the Checkout Widget, giving you more control over customization, behavior, and integration with your product’s purchasing flow.

🆕 What’s New

1. New Callback Support

You can now hook into key user interactions throughout the checkout flow using three new callbacks:

• onBillableFeatureChange - triggered when the value of plan's billable features (charges) changes
• onAddonChange - triggered when an add-on is added, removed, or updated
• onBeforeStepChange - invoked before the widget transitions between checkout steps

These callbacks give you deeper insight into user intent and allow for advanced analytics, validation, and UI coordination.

2. Add-on Visibility Configuration

The checkout widget now fully honors your add-on visibility rules.

You decide which add-ons are shown are shown to customers in Stigg widgets and the widget automatically enforces your configuration.

3. Support for Add-on Types

The widget now respects whether an add-on is:

• Single-instance (can be added once), or
• Multiple-instance (users can add multiple units)

This ensures that your packaging and purchasing rules are represented accurately in the UI.

4. Add-on Billing Period

The widget will now automatically hide add-ons that don't support the selected billing period.

5. Annual Prices in Summary

Prices in the summary will now appear in an annual format (e.g. $100.00 / year) when the selected plan only supports an annual billing period.

📦 Availability

These improvements are now available in the latest SDKs:

• React: v7.12.0
• Vue: v5.7.0
• Embed: v6.7.0

Ending trials using the Stigg app UI now takes effect instantly.

Once a trial ends, the subscription immediately transitions to the next applicable state (e.g., downgrade to a free plan, revoke entitlements, or convert to a paid subscription).

This updated behavior provides a more predictable and consistent user experience.

We’re excited to share that you can now configure credit top-ups and consumption within recurring paid plans.

🆕 What’s New

When creating or editing a recurring paid plan you can now:

• Define the credit currency that customers will able to top-up
• Map metered features to their credit consumption rate

Under-the-hood the new configuration leverages all of the constructs that we introduced as part of our support for prepaid credits, including: custom credit currencies, credit pools, credit grants and credit ledgers.

Credits (promotional or paid) can be granted to customers using the below methods:

• Programmatically via the Stigg API
• Through Stigg Workflows
• Directly in the Stigg App

💡 Why This Matters

Credits have become the standard for monetizing AI and other variable-cost features - they make usage predictable for customers and provide finance and product teams with a transparent, auditable, and scalable model.

This new functionality expands Stigg existing support for hybrid pricing models and allows you to extend your existing subscription-based offerings with with usage-based features that are monetized using credits.

🛠 Get Started

You can start configuring credit top-ups and consumption of paid plans in the Stigg app.

🍿 See It In Action

🔮 Coming Up Next - Recurring Credit Grants

To extend this even further, we’re planning to introduce Recurring Credit Grants - a powerful new capability that will allow you to automate ongoing credit issuance throughout the subscription lifecycle. Stay tuned!

🆕 What's New

You can now customize the number of skeleton plan loaders displayed while the Stigg Pricing Table widget is loading. This allows you to better align the loading state with your plan layout and create a smoother visual experience.

To configure it, simply set the new skeletonCount option when initializing the widget.

📦 Availability

• React SDK: v7.10.0
• Vue SDK: v5.6.0
• Embed SDK v6.6.0

🍿 See It In Action

We've made improvements to the infrastructure and scale of usage event ingestion from AWS S3, making it even easier than ever to migrate data, backfill usage, or integrate with complex data pipelines.

🌟 Feature Recap

Usage event ingestion from S3 allows you to:

• Ingest usage events directly from AWS S3 - Import raw usage events from a supported AWS S3 without building custom ingestion pipelines.
• Backfill historical usage at scale - Load months or even years of past events to support migrations, billing transitions, or customer onboarding.
• Sync of large volumes of events - Perfect for workloads that generate usage asynchronously, in batches, or from data processing pipelines.
• Leverage Stigg existing metering capabilities - Once ingested, events affect metering, consumption, entitlements, and credit burn without extra setup.

💡 Why This Matters

Our metering API is provisioned for 1000 events per second, which covers most workloads.  

For extremely high-volume cases, our infrastructure can scale beyond 100,000 events per second and process terabytes of data by using a bring-your-own-bucket object storage setup with dedicated ingestion channels and isolated storage capacity.

Until now, turning such high volume data into billable usage required custom ETL jobs, scripts, or fragile data plumbing.

With this capability, you can:

• Accelerate migrations from legacy billing or metering systems
• Unify real-time and batch usage under a single metering logic
• Reduce engineering overhead by eliminating custom ingestion code
• Trust Stigg to handle processing and enrichment of events
• Ensure billing accuracy even when usage is delayed or generated in bulk

📦 Availability

Usage Event Ingestion from AWS S3 is available to all customers of the Scale plan. See Stigg's pricing for more details.

🛠 Get Started

Full documentation and integration guides are available here.

We’re excited to announce expanded capabilities in Stigg Workflows - you can now provision and update subscriptions that include multiple billable features, add-ons, and variable entitlements in a single, streamlined flow.

This unlocks a more flexible and scalable way to automate complex subscription lifecycles.

🆕 What’s New

It's now possible to pass multiple values in a single Workflow action when provisioning and updating subscriptions using Stigg workflows, including:

1. Billable features of paid plans
2. Add-ons
3. Variable entitlements of custom plans

💡 Why This Matters

• Simplicity - reduces the number of required actions and significantly simplifies workflow complexity
• Atomicity - ensures that all updates take place at once.

📦 Availability

The new subscription provisioning and updates action nodes are now available to all Stigg customers using Workflows.

We’re excited to launch our new Credits Widget Suite - a set of embeddable, plug-and-play UI components that surface key credit-based usage insights inside your customer portal or product.

🌟 What’s Included

• Credit Balance Widget – shows the customer’s live credit balance. 
• Credit Utilization Widget – visualizes credits consumed vs available. 
• Credit Grants Table Widget – displays all credit grants (purchased, promotional, expired), their status, remaining amounts & expiry.  
• Credit Usage Chart Widget – provides a time-series view of credit consumption by feature or date, giving users insight into how credits are being spent.  

💡 Why This Matters

• Customer visibility & trust: Your end-users get clear, self-serve access to their credit balance, usage trends, and grant history - reducing billing friction and support load.
• Shorter time-to-market: Embed our widgets instead of building custom UI from scratch - get credit-based pricing visible in your product portal in hours, not weeks.
• Monetization acceleration: Customers see their spend, usage and remaining credits - making top-ups and add-ons more intuitive and timely.
• Full customization: Align the styling of the widgets with your brand using CSS.

🛠 How to Get Started

1. Integrate Stigg's frontend SDK in your application.
2. Choose which widgets make sense for your UX, for example: balance + utilization for quick view; grants + usage chart for deeper context.
3. Embed the selected widgets into your application.
4. Customize the widgets to fit your brand and product experience.
5. Launch to customers and monitor: you’ll gain insight into usage patterns, top-up behaviours, and potential opportunities for upsells.

Learn more in our documentation.

📦  Availability

This new widgets are available in the latest versions of our SDKs:

• React: v7.9.0
• Vue: v5.5.1
• Embed: v6.5.1

🍿 See it in action

• Credit Balance Widget
  
• Credit Utilization Widget
  
• Credit Grants Table Widget
  
• Credit Usage Chart Widget
  
  

We’ve added a powerful new capability to help teams better organize, segment, and sync customer data across systems: you can now filter customers directly by their Salesforce ID.

This update makes it easier to:

• Quickly locate customers tied to specific Salesforce records
• Align GTM, CS, and billing workflows around shared identifiers
• Ensure smoother debugging and cross-system reconciliation

This enhancement is now available in the Customer list page of the Stigg app and API.

We’re excited to introduce Custom Credit Consumption Formulas, giving you full control over how usage of metered features translates into credit burn - so your pricing can better reflect real customer value.

🆕 What’s New

• Define custom formulas that convert event data into credit deductions
• Use event dimensions (e.g., token count, number of files, duration) as formula parameters
• Apply different formulas per feature
• Get real-time credit deduction with full audit-trail visibility in the credit ledger
• Works seamlessly with all existing credit-based pricing models

💡 Why This Matters

• Dynamic credit calculation - Use event dimensions to determine the credit cost of each action - perfect for scenarios where usage isn't uniform. For example:

  • A summary action that processes X documents, Y emails, and Z images, where processing of each document, email and image costs a, b, and c credits respectively:

    → credits_used = (a × X) + (b × Y) + (c × Z)

  • A prototyping action using multiple LLMs under the hood, where consumed credits reflect a premium for each LLM model:

    → credits_used = (1.1 × Model1_Tokens) + (1.5 × Model2_Tokens) + (5 × Model3_Tokens)

  • → credits_used = Agent1_Tokens + Agent2_Tokens + Agent3_Tokens
• Flexibility - Define burn rates that accurately model your product’s complexity and value.
• Operational simplicity - Stigg handles real-time enforcement, credit tracking, audit logs, and metering—so you only focus on designing the right pricing formula.

🤔 Who This Is For

• Product teams offering AI, data processing, media, or any metered services that need granular usage-to-credit mapping
• Engineering teams wanting an easy, maintainable way to enforce complex credit-consumption logic at scale

🛠 How to Get Started

1. Go to your plan’s price configuration in Stigg
2. Under Credit Consumption, select the metered feature you want to configure
3. Choose Advanced calculation mode
4. Enter your formula using mathematical operators and event dimensions
5. Use the credit ledger and reporting dashboards to validate and refine your formula

🍿 See It in Action

We’re excited to introduce prepaid credits, giving you a flexible, transparent, and scalable way to monetize usage-based and AI-driven features.

🌟 What's Included

Core Concepts

• Credit currencies – Define your own credit types and unit costs (e.g., 1 AI Credit = $0.001).
• Credit pools – Real-time customer credit balances used across multiple features.
• Credit grants – Add blocks of credits with rules like amount, effective/expiration dates, category, cost basis, and priority.
• Credit consumption – Map metered features to credit costs (e.g., 1 summarized email = 3 AI credits).
• Credit ledger – A full audit trail of every credit change: grants, top-ups, consumption, expirations, and adjustments.

🆕 What's New

• Custom credit currencies
• Feature-to-credit mapping
• Near real-time credit deduction and enforcement
• One-time credit top-ups and self-service management
• Webhooks and activity log events (low balance, grant lifecycle)
• Full visibility into balance, utilization, grants, and usage
• Management via the Stigg app or customer self-service
• Native integration with all existing Stigg billing connectors

💡 Why This Matters

Credits have become the standard for monetizing AI and other variable-cost features. They make usage predictable for customers and provide finance and product teams with a transparent, auditable, and scalable model.

Most billing systems don’t support credits, forcing companies into complex migrations or expensive in-house builds. Stigg removes that friction and delivers:

• Flexibility – Update credit pricing and mappings without code. Use versioning to roll out changes safely.
• Neat real-time enforcement – Prevent overuse and protect margins with low-latency entitlement checks.
• Predictability – Customers purchase usage upfront, reducing billing surprises.
• Transparency – Every grant, deduction, and expiration is recorded for customers and finance.
• Speed to value – Launch credit-based pricing without engineering heavy lifting.

📦 Availability

Available for all Stigg customers in the Stigg app. 

Supported in the latest SDKs:

• Node.js: v4.0.0
• Python / Ruby / Go / Java / .NET: v3.75.0
• Sidecar SDK: v4.0.0
• JavaScript: v3.68.1

🛠 Get Started

Start monetizing like today's leading AI platforms. Learn more in our documentation.

🍿 See It In Action