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 = (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 = (1.1 × Model1_Tokens) + (1.5 × Model2_Tokens) + (5 × Model3_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

We’ve added a new webhook event to help you stay ahead of upcoming changes in customer entitlements: promotionalEntitlement.ends_soon.

This event fires 7 days before a promotional entitlement expires, giving your team or systems time to react proactively.

With this new event, you can:

• Notify customers in advance that a promotion is ending
• Trigger automated outreach or renewal campaigns
• Notify sales and CS in advance about changes to customers entitlements
• Build custom retention or upsell automations

This enhancement makes it easier to deliver a smoother customer experience while improving operational visibility.

We’ve expanded our webhook capabilities with a set of lifecycle events for the product entity, giving you deeper visibility and real-time automation around changes to your product catalog.

You can now subscribe to webhook events for:

• product.created – Triggered when a new product is created
• product.updated – Fired whenever product details are modified
• product.deleted – Sent when a product is removed

These events make it easy to:

• Keep internal systems (CRM, analytics, etc.) in sync
• Automate downstream workflows whenever products change
• Maintain a clean, up-to-date source of truth across your stack
• Build custom operational or go-to-market processes on top of product events

Whether you’re coordinating pricing updates, syncing product metadata, or triggering internal alerts—these lifecycle events give you full control.

You can learn more about these events and their payload in our webhook API reference.

We’ve expanded the flexibility of event-based meters with a new set of powerful filters that give you much finer control over how usage is counted.

You can now filter events using:

• Starts with
• Ends with
• Contains
• In (list of values)

These new operators make it easier than ever to measure usage based on specific attributes.

• Stigg Sidecar - running alongside your app or as a standalone service for low latency, resilient entitlement checks
• Persistent Cache Service - for streaming entitlement updates into your Redis storage
• Redis - for local storage when persistent cache is enabled
• An end-to-end example app - showing how all components work together

• A repeatable and production-ready way to deploy Stigg components on Kubernetes
• Built-in support for API key management, autoscaling, resource limits, and secure Redis communication
• Example manifests and templates that make it simple to integrate Stigg into existing workloads

1. Clone the stigg-helm-charts repo
2. Follow the instructions in README.md for either the Helm or the Kubectl + Kustomize deployments.

🔐 What changed

Stigg’s Snowflake integration now supports key pair authentication instead of username and password.
In this new flow, the public key is stored inside your Snowflake user configuration, and the private key is securely uploaded in Stigg.

This change ensures stronger security and aligns with Snowflake’s deprecation of username + password authentication.

💡 Why it matters

Snowflake is deprecating password-based authentication to strengthen account protection.
At Stigg, we have a deep sense for customer security and have therefore set key pair authentication as the default method for all new Snowflake integrations.

📦 Availability

• Default for all new Snowflake integrations.
• Existing customers can migrate to the new authentication method using the migration guide in our documentation.

⚙️ How to use it

1. Go to Integrations → Snowflake in your Stigg account.
   
   
   
2. Generate your key pair using the provided commands.
   
   
3. Add the public key to your Snowflake user configuration.
4. In Stigg, upload the private key (and optional passphrase) to connect.
   
   
5. To rotate keys later, upload a new private key and update the corresponding public key in Snowflake.

Full guide: Stigg documentation

We’re excited to announce the addition of new webhook events that give you greater visibility and control over your feature group lifecycle.

🆕  What’s New

You can now subscribe to the following webhook events:

• feature_group.created – Triggered when a new feature group is created.
• feature_group.updated – Triggered when changes are made to an existing feature group.
• feature_group.archived – Triggered when a feature group is archived.
• feature_group.un_archived – Triggered when a previously archived feature group is restored.

💡 Why It Matters

These new events enable you to:

• Keep external systems (dashboards, CRMs, analytics) in sync with your feature group activity.
• Automate workflows, such as notifying your team when new feature groups are created or monitoring changes to existing ones.
• Gain deeper observability into feature group lifecycle management.

📦 How to Get Started

• Head to the Integrations > Webhooks section in the Stigg app.
• Select the events you want to subscribe to.
• Start receiving real-time notifications for feature group activity.

We’re excited to announce that Zuora is now supported in the Stigg Checkout widget 🎉.

🆕 What’s New

• Seamless Zuora integration – Customers using Zuora can now process subscriptions directly through the Checkout widget, just like with other billing providers.
• No changes to the checkout experience – Your end-users continue to see the same familiar, streamlined flow — no code changes required.
• Multi-billing flexibility – Works seamlessly alongside Stigg’s multiple billing provider integration.
• Transparent migrations – Makes it easier to switch or migrate between billing providers without disrupting the checkout flow.

💡 Why It Matters

• Flexibility – Choose the billing provider that best fits your business without worrying about the checkout UI.
• Future-proofing – Easily support multiple billing providers as your business scales.
• Smoother migrations – Switch billing providers with zero impact on the customer-facing purchase experience.

📦 Availability

This functionality is supported in the latest versions of our SDKs:

• React: v6.11.0
• Vue: v5.3.0
• Embed: v6.3.0

🍿 See in action

👉 With Zuora support, Stigg Checkout gives you even more flexibility and peace of mind when managing billing across providers.

Managing large sets of features is critical as we scale upmarket and support enterprise-grade use cases. To make this easier, we’re introducing Feature Groups — a reusable way to organize, manage, and grant entitlements to groups of related features.

🔑 Why Feature Groups?

• Simplified management – Instead of handling hundreds of individual features, you can group them into logical sets.
• Consistency across plans – Ensure related features are always bundled and managed together.
• Faster packaging & updates – Grant, update, or revoke access to entire groups at once, rather than feature by feature.

🆕 What’s New

• Feature Group entity – Create, update, and archive groups of features. Each group has an ID, name, description, and list of features.
• Versioning – Feature Groups are versioned, making it easy to track and update changes across plans and add-ons.
• Plan & Add-on integration – Add entitlements by selecting a Feature Group; all included features are added automatically.
• Promotional entitlements – Grant promo access to entire groups just as you would with plans and add-ons.
• Visibility & management – See which groups a feature belongs to, update groups across environments, and export them to your data warehouse.

💡 Benefits

• Enterprise scalability – Handle hundreds of features with ease.
• Flexibility – A feature can belong to more than one group, supporting complex packaging needs.
• Transparency – Teams can see which entitlements belong to groups, and update plans/add-ons accordingly.
• Consistency – Version control ensures alignment across environments and plans.

📦 Availability

Managing feature groups is supported via the Stigg API.

Granting and revoking access to feature groups via promotional entitlements is supported in the latest versions of our SDKs:

• Node.js: v3.89.0
• Python / Ruby / Go / Java / .NET: v3.68.0
• Sidecar SDK: v3.72.0

🍿 See it in action

➡️ What's next

We’re adding dedicated webhook events to notify on creation, updates and archiving of feature groups — stay tuned!

👉 With Feature Groups, managing features at scale becomes simpler, faster, and more reliable — whether you’re bundling features into enterprise plans, granting promos, or aligning entitlements across environments.