Custom contract terms - like special usage allowances, delayed discounts, or non-standard renewal clauses - often live in signed PDFs or CRM opportunities, separated from entitlement systems and billing platforms. This separation creates operational overhead and causes real-time feature access to drift away from invoice details.

We're excited to announce Contract Management, a single unified solution in Stigg that bridges entitlement provisioning and complex enterprise invoicing!

🆕 What’s new?

A Contract in Stigg represents a signed order form that combines entitlement enforcement with invoice generation:

• Entitlement Provisioning: Grant customers access to features by linking or creating subscriptions to custom plans and add-ons directly from an order form.
• Flexible Billing Contracts: Define payment terms, billing schedules, currencies, and custom line items (including setup fees, support, or catalog items) to automatically generate enterprise invoices.
• Seamless Usage-Based Billing: Connect metered features (e.g., API calls, seats, or tokens) directly to line items. Usage reported to Stigg simultaneously enforces entitlement limits and calculates billed quantities on invoices.
• Multi-Entity & Consolidated Invoicing: Bill through designated legal entities (with custom addresses, logos, and tax/VAT settings) and choose whether line items consolidate onto a single invoice or issue separately with independent billing anchors and payment terms.

💡 Why it matters

• Zero System Drift: Enforce what was sold without manual cross-checks or custom scripts - entitlements and invoices stay perfectly in sync.
• End-to-End Enterprise Flexibility: Support any line item, pricing model, billing cycle (monthly, quarterly, yearly, custom), or payment term (in advance or in arrears) without leaving Stigg.
• Works with Your Existing Stack: Operates natively on top of tools like Stripe Billing and NetSuite without disrupting existing product-led growth (PLG) workflows.

⚒️ Get started

1. Navigate to the Customers > Contracts section and click + Add.
2. Select an existing customer or create a new one.
3. Upload the signed order form (PDF, PNG, JPG).
4. Configure Entitlement Provisioning, Billing Contract terms/line items, and assign the appropriate Legal Entity.
5. Review the financial summary (Total Contract Value, Year 1 Billing, cash inflows chart) and click Publish.

📦 Availability

Contract Management is now available in Public Beta to all Stigg customers.

To learn more about setting up contracts and usage-based billing rules, check out our Contract Management Documentation.

🍿 See it in action

The Stigg Governance Skill gives your AI coding assistant the exact context it needs to help implement Usage Governance correctly, from modeling entity hierarchies and assigning usage limits to reporting usage and enforcing budgets.

It eliminates setup friction by training your agent on Stigg's Governance concepts, API patterns, and edge-case handling, taking you from initial hierarchy design to working enforcement in minutes.

🆕 What’s New

With the Governance Skill, your AI coding assistant can help you:

• Model entity types and hierarchies: Define multi-level parent-child structures across organizations, departments, teams, users, and AI agents using natural language.
• Assign contextual limits: Configure independent usage limits and reset cadences for features and credit wallets at any node in the hierarchy.
• Attribute multi-dimensional usage: Implement usage events that count against multiple entity levels simultaneously.
• Integrate real-time checks: Write robust entitlement checks that pass contextual metadata (like workspaceId or agentId) for precise access decisions.
• Query tree states: Fetch hierarchy structures, child node usage, and remaining credit balances.

⭐️ Why It Matters

Building multi-tiered governance manually usually means digging through dense API docs and wrestling with complex schema design.

By embedding Stigg's governance architecture directly into your AI assistant's memory, you can simply describe your desired domain model (e.g., "Set up a 1,000 credit monthly cap for Workspaces, with a 50 credit daily sub-limit for AI Agents"), and let your agent generate production-ready code instantly.

📦 Availability

The Governance Skill is available now across Stigg's AI-assisted development tools and MCP server integration.

If you're participating in the Usage Governance Private Beta, update your local Stigg AI skills to start using run: npx @stigg/terminal

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