Configuring custom contract terms just got simpler and error-free. We’re excited to announce subscription metadata suggestions in Stigg, designed to streamline setting up termed subscriptions when integrated with Zuora!

When creating or editing a subscription in Stigg, relevant Zuora metadata keys and allowed values will now automatically be suggested, taking the guesswork out of contract term configurations.

🆕 What's new?

We’ve updated the Stigg Console to automatically surface metadata key-value suggestions specific to Zuora’s termed subscription model:

• Contextual Auto-Suggestions: As soon as you add metadata during subscription creation or editing, Stigg automatically suggests key names (e.g., zuora_initialTerm, zuora_renewalSetting, zuora_termType) and valid options directly in the UI.
• Built-in Validation: Ensure metadata key names and values match exact Zuora specifications before saving, avoiding configuration typos or sync failures.
• Full Termed Subscription Support: Easily configure parameters like initial term length, renewal term length, period types (days, months, years), and renewal behaviors (auto-renew, convert to evergreen, or out-of-term) with instant UI guidance.

⭐️ Why it matters

• Faster Operations: RevOps, Sales, and Customer Success teams no longer need to copy-paste or memorize technical metadata keys from documentation.
• Eliminate Integration Errors: Prevent failed contract syncs or misconfigured Zuora amendments caused by missing or misspelled metadata tags.
• Seamless Contract Flexibility: Easily convert evergreen subscriptions to termed agreements (or vice versa) straight from the Stigg UI using accurate, pre-populated metadata fields.

⚒️ Get started

1. In the Stigg app, open a subscription.
2. Scroll down to the Metadata section and start typing to see automatic key and value suggestions for Zuora termed subscriptions.

For a full list of supported metadata keys and detailed examples, check out our Zuora Termed Subscriptions Documentation.

📦 Availability

Metadata suggestions are available out-of-the-box for all Stigg accounts integrated with Zuora Billing.

🍿 See it in action 

Provisioning enterprise deals with uncapped access just got easier. We’re excited to announce support for unlimited entitlements in the Stigg Salesforce integration!

You can now provision subscriptions with "unlimited" entitlements directly from Salesforce, eliminating manual workarounds when closing sales or configuring custom enterprise packages.

🆕 What’s new?

Our updated Salesforce integration gives you full flexibility to define and customize how the "unlimited" value is passed from Salesforce into Stigg:

• Direct Unlimited Provisioning: Easily grant unlimited feature entitlements straight from your Salesforce workflow.
• Automated Entitlement Sync: Uncapped entitlements seamlessly flow into Stigg subscriptions while keeping your revenue and subscription logic aligned.

💡 Why it matters

• Streamline Enterprise Sales: Enable sales and RevOps teams to close and provision complex deals with uncapped features directly inside Salesforce.
• Adaptable to Your Catalog: Map unlimited values according to your team's existing Salesforce product catalog setup without restructuring your data.
• Eliminate Manual Errors: Avoid manual post-sale adjustments in Stigg by automating entitlement provisioning from the moment the deal closes.

⚒️ Get started

Getting set up takes just a few steps:

1. Install or update the Stigg package in Salesforce.
2. Add the Stigg Unlimited Usage field to the Product layout.
3. Create a Salesforce product with Stigg Type = Entitlement and turn the Stigg Unlimited Usage checkbox ON.

For full setup details, visit our documentation.

📦 Availability

The new configuration is available in Stigg package for Salesforce v1.15 or later. 

🍿 See it in action

Managing usage-based pricing models just got more flexible. We're excited to announce general availability for overage charges on metered features and credits in Stigg!

Until now, reaching a usage cap or running out of pre-purchased credits typically meant blocking user access or requiring an immediate plan upgrade. With this release, you can allow customers to seamlessly exceed their base allocations or credit limits and bill them automatically for any overage accrued.

🆕 What’s new?

You can now configure overage billing rules directly within your price models for both metered features and credit balances via the Stigg Console, API, and billing integrations.

• Metered Feature Overages: Define overage tiers and unit rates when customers exceed included feature entitlements (e.g., charge $0.05 per extra API call or $10 per additional GB of storage beyond their base allocation).
• Credit Balance Overages: Allow customer usage to continue after their credit balance reaches zero, charging per unit or per credit drawdown in overage mode.
• Automatic Invoicing: Accrued overages are automatically calculated, aggregated, and billed at the end of the billing cycle (or upon subscription renewal) via your connected payment gateway.

💡 Why it matters

• Frictionless Customer Experience: Avoid hard paywalls that interrupt your users' product workflows when they exceed their limits.
• Monetize Spikes in Usage: Capture revenue from high-usage periods and enterprise power users without forcing them through manual plan upgrades.
• Granular Pricing Control: Mix base recurring fees, included usage thresholds, credit pools, and overage rates to construct predictable yet flexible hybrid pricing strategies.

⚒️ Get started

Using the Stigg app:

1. Navigate to a paid plan and edit it.
2. Under the Price section, click on Edit.
3. In the wizard, navigate to the Overage charges section and select the metered feature or credit currency that you'd like to bill customers for.
4. Save and publish the changes.

For API-first workflows, configure overage tiers via GraphQL/REST, or just use the Stigg AI terminal with natural language.

🍿 See it in action

We’ve shipped a series of web app performance optimizations, making your daily workflows across customers, subscriptions, plans, add-ons, and paywalls significantly faster and more responsive.

🆕 What’s New

We overhauled how the Stigg app fetches, caches, and reuses data across core dashboards and workflows:

• Faster subscription pages: Subscription details now reach an interactive state ~36% faster.
• Earlier customer page rendering: Customer profile pages now render essential account metadata instantly without blocking on secondary data requests.
• Smarter client-side caching: Customer, subscription, catalog, and paywall data is intelligently cached and reused during navigation, fetching fresh data seamlessly in the background.
• Prefetching on hover: Hovering over customer records, plans, or add-on links automatically pre-loads the detail pages before you even click.
• Optimized catalog requests: Server-side caching reduces query overhead for products, plans, entitlements, and paywalls.

⭐️ Why It Matters

Less waiting. Less jumping around. More getting things done.

Whether you're managing customers, checking entitlements, or updating your pricing catalog, these improvements make everyday workflows in Stigg feel noticeably faster and smoother.

Managing fixed-term contracts just got a lot cleaner. We are excited to announce the ability to pass a cancellation date (end date) directly when provisioning or updating subscriptions in Stigg!

By default, subscriptions in Stigg are evergreen (auto-renewing). While this works perfectly for self-service self-renewing plans, sales-led motions often require fixed-term, non-recurring subscriptions. This update eliminates the manual overhead of handling these contracts.

🆕 What’s new?

You can now explicitly set an expiration date for a subscription at the exact moment of creation or during an update via the Stigg app, API and Salesforce integration. 

By passing the new cancellationDate parameter, Stigg handles the subscription lifecycle and schedules its termination automatically.

💡 Why it matters

• Consolidated API Workflows: Previously, creating a fixed-term subscription required two separate API calls - one to provision the subscription and a second to schedule its cancellation. Now, you can complete this entire workflow in a single, atomic request.
• Streamlined Sales-Led Operations: Seamlessly model precise, non-recurring enterprise pilots, short-term contract extensions, or fixed-duration proof-of-concepts without worrying about stray auto-renewals.

🍿 See it in action

⚒️ Get started

To provision a fixed-term subscription, simply include the cancellationDate (ISO-8601 string) directly when provisioning or updating subscriptions.

To implement this workflow, update your backend provisioning service to map contract end-dates directly to the cancellationDate input field. 

📦 Availability

The cancellationDate parameter is supported across the Stigg API and our latest server-side SDKs:

REST-based SDKs

• TypeScript: v0.1.0-alpha.31
• Python: v0.1.0-alpha.31
• Go: v0.1.0-alpha.29
• Java: v0.1.0-alpha.52
• Ruby: v0.1.0-alpha.29

GraphQL-based SDKs

• Node.js: v4.40.0
• Python / Java / Go / .NET: v6.10.0
• Ruby: v6.8.0

Salesforce integration

Version 1.14.0 or later.

Allow your customers to govern their usage directly according to your app’s internal entities, from organizations and departments down to individual teams, users, and AI agents.

Usage Governance lets you meter consumption, deliver end-to-end visibility, and enforce granular access controls across multi-level entity hierarchies, all seamlessly integrated with Stigg’s account-level entitlements.

🆕 What's New

Meter & Attribute Consumption

• Reflect how your customers actually operate: Model any organizational entity, from top-level accounts down to teams, users, and AI agents, using clean business logic instead of technical workaround configurations.
• Multi-level entity hierarchies: Build nested parent-child relationships across n-levels of depth to match how your enterprise customers operate.
• Multi-dimensional event attribution: Attribute a single usage event across multiple entities simultaneously (e.g., counting an AI request against a workspace, a team, and an AI agent at once).
• Flexible metering support: Govern raw events, metered usage, and credit-based wallets through the exact same hierarchy.

Visibility Before Enforcement

• Usage tracking before limits: Let both your engineering team and your end-customers track consumption rollups across the hierarchy first, giving admins complete visibility before introducing hard or soft caps.

Context-Aware Enforcement

• Assign limits at any tier: Set independent usage caps and reset cadences at any level (e.g., a monthly workspace credit wallet alongside daily per-agent rate caps).
• Contextual entitlement checks: The more context you pass during entitlement checks (e.g., customerId, workspaceId, agentId), the more granular and precise the access response becomes.
• Seamless integration: Works out of the box alongside existing Stigg account-level plans and entitlements.

⭐️ Why It Matters

Winning enterprise AI deals requires built-in control. Usage Governance is mandatory to move upmarket, because enterprise buyers hesitate to adopt usage-based products when a single user or runaway AI agent can drain a shared credit balance without oversight.

Lacking context-aware governance, companies face two major hurdles:

• Account admins have no visibility into which team, department, or agent is driving up usage.
• Engineering teams end up spending months building custom allocation schemas and enforcement layers in-house.

Stigg is the only usage platform built to deliver millisecond-latency governance out of the box, allowing you to unlock enterprise tiers instantly without rewriting your application backend.

🍿 See it in action

📦 Availability & Getting Started

Usage Governance is available today in Private Beta.

• Stigg app: Open Governance from the navigation menu in the Stigg app and click Request Access to join the beta.
• AI Coding Assistants: Configure entities, hierarchies, and governance rules directly using your AI coding assistant (Claude Code, Cursor, VS Code) via Stigg's dedicated governance AI skills.
  
  📚 Explore core concepts and step-by-step integration guides in the Usage Governance Documentation.
  
  
  
  

Stigg now provides dedicated estimation endpoints for usage events and usage measurements.

The estimation uses the same credit calculation logic as actual usage consumption, but does not ingest the event or deduct credits.

For each relevant credit currency, the response includes:

• estimatedCost — The number of credits the usage would consume
• currentBalance — The customer’s current credit balance
• balanceAfterEstimate — The projected balance after the estimated consumption
• wouldOverdraft — Whether the operation would take the balance below zero
• breakdown — A per-feature breakdown of the estimated credit cost
• warnings — Any limitations or unsupported calculations encountered during estimation

Estimations support both customer-level and resource-level usage, including custom event dimensions.

⭐️ Why It Matters

For products with dynamic pricing models, such as LLM workflows, media rendering, or multi-step API pipelines, the credit cost of an action isn't always known up front.

Credit cost estimation enables you to:

• Build pre-flight confirmation flows: Show customers an accurate estimate before launching an expensive task (e.g., "This image generation will cost ~15 credits. Proceed?").
• Prevent mid-task overdrafts: Evaluate wouldOverdraft to block heavy jobs before execution if a user lacks sufficient credits.
• Eliminate calculation drift: Ensure UI estimates perfectly match actual deductions by relying on Stigg's engine rather than re-implementing billing math in your frontend.

⚠️ Current Limitations

Aggregation types: For event-based estimation, COUNT and SUM aggregations are supported. UNIQUE and MAX are not currently supported as they rely on historical aggregation state.

📦 Availability

Credit cost estimation is available now through the Stigg REST API and the following REST SDK versions or later:

• TypeScript: v0.1.0-beta.43
• Python: v0.1.0-beta.38
• Go: v0.1.0-beta.39
• Java: v0.1.0-beta.37
• Ruby: v0.1.0-beta.41

The reportUsage response now includes a consumed field, showing exactly how many credits were deducted by each individual usage report.

✨ What’s New

Previously, the reportUsage response returned the customer’s updated credit usage, but it did not clearly indicate how many credits were consumed by that specific request.

With this update, the credit object returned by reportUsage now includes:

• consumed — The number of credits deducted by this specific reportUsage call
• currentUsage — The customer’s total credit usage across the wallet

Idempotency handling: For duplicate/retry requests with the same idempotency key, consumed returns 0. This makes it effortless to verify that a retried request did not trigger a duplicate credit deduction.

⭐️ Why It Matters

While tracking the total balance is necessary for access control, backend applications often need to log or display the direct impact of individual operations—especially when credit costs are dynamic (e.g., variable LLM token consumption).

The consumed field enables you to:

• Display per-action costs: Show end users instant feedback on how many credits a specific task, AI prompt, or API request consumed.
• Audit idempotency instantly: Safely confirm whether a network retry resulted in a fresh deduction or was recognized as a duplicate (consumed: 0).
• Simplify logging & reconciliation: Debug usage calculations and keep your internal database or audit logs perfectly in sync without manually diffing previous balance states.

📦 Availability

The consumed field is available now in the reportUsage response across Stigg’s REST, GraphQL APIs, and server SDKs:

REST-based SDKs

• TypeScript: v0.1.0-beta.49
• Python: v0.1.0-beta.43
• Go: v0.1.0-beta.44
• Java: v0.1.0-beta.41
• Ruby: v0.1.0-beta.46

GraphQL-based SDKs

• Node.js: v4.50.0
• Python / Go / .NET: v6.18.0
• Java: v6.19.0
• Ruby: v6.16.0

We’ve launched a new Spotlight search experience that makes it faster to navigate across Stigg and jump directly to the resources you need.

✨ What’s New

Press CMD + K (or Ctrl + K) anywhere in the Stigg app to open Spotlight.

Instead of clicking through sidebar menus and paginated tables, you can instantly search for and jump to resources across your entire workspace, including:

• Customers & Subscriptions: Find specific accounts, active plans, or billing states.
• Product Catalog: Jump straight to feature flags, entitlements, plans, and add-ons.
• Developer Resources: Quickly access environment settings, API keys, and webhooks.

This new experience replaces the previous command-bar component with a faster, Stigg-native search engine designed for speed.

⭐️ Why It Matters

As your Stigg environment grows with hundreds of customers, feature, and plan variations, navigating via sidebars slows down your workflow.

Spotlight enables you to:

• Keyboard-first navigation: Jump between any page or resource in seconds without taking your hands off the keyboard.
• Frictionless workflow: Find customer accounts or configuration screens instantly without manually searching through list views.
• Built for scale: Move quickly even when managing complex, multi-environment setups.

🍿 See it in action

📦 Availability

The new Spotlight search is available now for all customers.

Press CMD + K (macOS) or Ctrl + K (Windows/Linux) anywhere in the Stigg app to try it out.

All Stigg REST SDKs now route requests through edge.api.stigg.io by default, improving latency while keeping your existing integrations unchanged.

✨ What's New

REST SDKs now send requests through edge.api.stigg.io, which transparently proxies requests to api.stigg.io.

For supported endpoints, requests are served directly from the Edge, reducing latency without requiring any changes to your application or SDK configuration.

The following endpoints are currently served directly from the Edge:

• GET /api/v1/customers/{customerId}/entitlements/check
• GET /api/v1/customers/{customerId}/entitlements

⭐️ Why It Matters

Entitlement checks sit directly on your application's request path. Every millisecond saved on an entitlement check translates directly to a faster, more responsive app for your users.

• Zero-config performance: Lower latency out of the box without needing to configure custom routing, edge nodes, or caching layers.
• 100% backward compatible: You don't need to update API base URLs, implement custom proxy logic, or change how you instantiate Stigg SDK clients.
• Global low latency: Entitlements are evaluated closer to where your traffic originates.

📦 Availability

The Edge routing is available in the following REST SDK versions (or later):

• TypeScript: v0.1.0-beta.34
• Python: v0.1.0-beta.30
• Go: v0.1.0-beta.31
• Java: v0.1.0-beta.29
• Ruby: v0.1.0-beta.33

Simply upgrade your SDK dependency to the latest version to automatically benefit from Edge routing.