NetLicensing
NetLicensing is a software license management platform for administering products, license models, licensees, licenses, and commerce workflows.
Verdict
Common use cases
- Provision trial licenses for new signups
- Check out floating seats during user login
- Bundle license templates into SKUs
- Validate entitlements before feature access
- Release expired floating sessions in batch
Integration
- Vendor
- NetLicensing
- Category
- developer-tools
- Auth
- API_KEY
- Tools
- 21
- Composio slug
netlicensing
Tools
- Check In Licensee Session
Return and release a NetLicensing floating-license session for a licensee and return the validation results and provider cache TTL when supplied.
- Check Out Licensee Session
Allocate a NetLicensing floating-license session for a licensee and return the validation results with their cache TTL.
- Create Bundle
Create a purchasable NetLicensing bundle from existing license templates.
- Create License
Assign a license from a license template to a licensee.
- Create Licensee
Create a licensee under a product so licenses can be assigned and validated.
- Create Licenses From Bundle
Create one or more licenses for a licensee from the license templates associated with a bundle.
- Create License Template
Create a license template under a product module using a supported license type.
- Create Product
Create a NetLicensing product that can contain product modules and licensees.
- Create Product Module
Create a licensing-model-specific module under a NetLicensing product.
- Delete Resourcedestructive
Permanently delete a product, product module, license template, licensee, license, or bundle by number. Optional cascade deletion is limited to supported resource types.
- Get Resource
Get one product, product module, license template, licensee, license, transaction, or bundle by its NetLicensing number.
- List Licensing Options
Return the supported licensing models and license types used when configuring product modules and license templates.
- List Resources
List one page of products, product modules, license templates, licensees, licenses, transactions, or bundles for the connected vendor.
- Transfer Licenses
Irreversibly transfer all eligible licenses from a source licensee marked for transfer to a target licensee in the same product.
- Update Bundle
Update selected bundle details or replace its complete set of license templates. At least one mutable field is required.
- Update License
Update a license's identity/number, name, parent-feature relationship, status, timing, pricing, visibility, or quantity. At least one mutable field is required.
- Update Licensee
Update selected status, identity, transfer, or non-secret custom properties of a licensee. At least one mutable field is required.
- Update License Template
Update selected pricing, visibility, limits, or license behavior on a license template. At least one mutable field is required.
- Update Product
Update selected properties of an existing product; supplying discounts replaces the complete discount set, and an empty discounts list clears all discounts by sending one empty discount field. At least one mutable field is required.
- Update Product Module
Update selected properties and model-specific settings of a product module. At least one mutable field is required. When provided, non-empty node_secret_modes and license_template_types arrays each replace the complete corresponding set; om
- Validate Licensee
Validate a NetLicensing licensee's active licenses and return the validation results with their cache TTL. Depending on the configured product, validation may auto-create the licensee when licensee_name and product_number are supplied.
Setup
Setup guide
- 11. Open your Switchy workspace and navigate to Settings → Integrations → Developer Tools. 2. Click 'Connect' next to NetLicensing. 3. Log into your NetLicensing account and generate an API key from the API Access section of your dashboard. 4. Paste the API key into Switchy's connection dialog and click 'Authorize'. 5. Switchy confirms the connection by fetching your product list. 6. Open any Project and type '@NetLicensing list products' to verify the integration works. 7. If you see your products listed, the connection is live and you can invoke any of the 21 tools by @mentioning NetLicensing in a prompt.
What teammates see: by default, memories from NetLicensing are scoped to the Project (PROJECT visibility) - you can mark any memory PRIVATE or share it ORG-wide.
Works well with
Top models
Compatibility data appears once enough Projects have used this MCP together with a given model.
How Switchy teams use it
Starter prompts
Create Trial Licensee
@NetLicensing create a licensee named 'trial-user-12345' under product 'PROD-DEMO' and assign a 14-day trial license from template 'LT-TRIAL'.
Check Out Floating License
@NetLicensing check out a floating license session for licensee 'user-67890' and show me the validation results and session expiry.
Bundle Templates Into SKU
@NetLicensing create a bundle named 'Startup Pack' that includes license templates 'LT-BASIC' and 'LT-API-ACCESS' with a price of 99 USD.
Validate Licensee Entitlements
@NetLicensing validate licensee 'user-34567' and list all active entitlements with their expiration dates.
Release Expired Sessions
@NetLicensing list all active floating sessions older than 8 hours and release them to reclaim available seats.
Example outputs
Illustrative - representative of the model's voice and quality, not literal recordings.
@NetLicensing check out a floating license session for licensee 'dev-team-alpha' under product 'analytics-suite' and show me the validation results with cache TTL
Floating license session allocated successfully for licensee 'dev-team-alpha'. Validation results: License active, expires 2024-12-31, feature set includes 'advanced-analytics' and 'export-api'. Session ID: fls_8k3m9n2p. Cache TTL: 3600 seconds (1 hour). This session will auto-release after 8 hours of inactivity or can be manually checked in. Current concurrent usage: 4 of 10 seats.
This example shows NetLicensing's floating-license model in action. Requires API_KEY with 'licensee:validate' scope. The checkout creates a stateful session that must be checked in later to free the seat—forgetting to release sessions will block other users once the seat limit is reached.
@NetLicensing create a new licensee called 'customer-acme-corp' under product 'saas-platform', then assign them a license from template 'pro-tier-annual'
Licensee 'customer-acme-corp' created successfully under product 'saas-platform' (ID: lic_9x4k2m). License assigned from template 'pro-tier-annual': License ID lic_template_7h3n, valid from today through 2025-11-15, includes modules 'core-features' and 'priority-support'. Licensee is now authorized to validate against this license. No payment gateway integration detected—license activation is immediate.
Demonstrates the two-step provisioning workflow: create the customer entity, then grant entitlements. This is the write-heavy side of NetLicensing's licensing-as-a-service model. Requires 'licensee:create' and 'license:create' scopes. Side-effect: the licensee can immediately validate and consume the license.
@NetLicensing list all active licenses for product 'mobile-sdk', group them by license template, and summarize which licensees are close to their usage limits
Product 'mobile-sdk' has 47 active licenses across 3 templates. Template 'starter-monthly' (12 licenses): all licensees under 50% usage. Template 'pro-annual' (28 licenses): 3 licensees above 80% usage—'customer-beta-inc' at 94% (47/50 API calls), 'dev-team-gamma' at 87%, 'partner-xyz' at 82%. Template 'enterprise-unlimited' (7 licenses): no usage caps. Recommend contacting the three high-usage pro-tier licensees about upgrades before they hit limits.
This synthesis example pairs NetLicensing's read APIs with AI reasoning to surface actionable insights. The MCP fetches raw license and usage data; the AI aggregates and flags at-risk customers. Useful for proactive license management. Note: usage metrics depend on your product's telemetry integration with NetLicensing.
Use-case deep-dives
When floating licenses beat per-seat billing for small teams
A 10-person dev shop selling a desktop tool to enterprise clients needs to enforce seat limits without building license infrastructure. NetLicensing's Check Out/Check In session tools handle floating licenses—clients buy 5 seats, any 5 users can be active at once, sessions release when users log off. The Create Licensee and Create License tools let you provision customers via API after Stripe webhooks fire. The trade-off: if you're selling pure SaaS with always-on browser sessions, floating licenses add complexity you don't need—stick with database flags. But if your product is installed software or has intermittent usage patterns, NetLicensing's 21 tools cover the entire license lifecycle without you writing expiration logic, grace periods, or trial flows. Worth the API_KEY setup if licensing is a product feature, not just a billing gate.
How bundle templates speed up partner onboarding
A 3-person team runs a white-label analytics platform sold through 8 regional resellers. Each reseller needs to provision end-customer licenses with different feature tiers (Basic, Pro, Enterprise) without touching your admin panel. NetLicensing's Create Bundle and Create Licenses From Bundle tools let you define bundles once—say, 'Starter Pack' includes 3 Basic licenses and 1 Pro—then resellers call the API to instantiate those bundles for their customers. The Create Product and Create License Template tools set up the SKU catalog; the Create Licensee tool maps each end-customer. This works when resellers are technical enough to call an API or you build them a thin UI. If resellers expect a full self-service portal with invoicing and usage dashboards, you'll still need to build that layer on top. But for pure provisioning automation, the bundle model cuts onboarding from 20 minutes of manual clicks to one API call.
When license templates clarify upgrade paths better than feature flags
A 5-person B2B startup offers a 14-day trial, then converts users to monthly or annual plans with different API rate limits. You could track this with database columns and cron jobs, but NetLicensing's Create License Template tool lets you model Trial, Monthly, and Annual as distinct license types with built-in expiration and validation. When a trial user converts, you call Create License to assign the paid template to their licensee record; your app calls the validation endpoint and gets back the current entitlements and TTL. The upside: licensing logic lives outside your app code, so product can tweak trial length or add a grace period without a deploy. The downside: if your pricing is usage-based (pay-per-API-call) rather than time-based, NetLicensing's seat-and-expiration model doesn't fit—you'd need a metering service instead. Best for products where entitlements are binary (feature on/off, seat count) and change on calendar boundaries.
Frequently asked
What does the NetLicensing MCP do in Switchy?
It lets your AI agents manage software licensing workflows directly — creating products, assigning licenses to customers, validating entitlements, and handling floating-license sessions. Instead of manually clicking through NetLicensing's dashboard or writing API scripts, your team can ask an agent to provision a trial license, check a customer's active modules, or bundle license templates for a new pricing tier.
Do I need admin access to connect NetLicensing?
You need a NetLicensing API key with write permissions to products, licensees, and licenses. Read-only keys won't work because the MCP creates and modifies licensing entities. Generate the key in your NetLicensing vendor account settings, then paste it into Switchy's connection flow. The key stays encrypted in your workspace; agents use it only when you invoke NetLicensing tools.
Can the MCP validate licenses in real time for my app?
Yes, but indirectly. The MCP can check out and check in floating-license sessions, which returns validation results and cache TTL. For production license checks embedded in your application, you'd still call NetLicensing's validation API directly from your backend. Use the MCP for provisioning, auditing, and one-off validation queries during support or sales workflows.
How does this compare to using NetLicensing's dashboard?
The dashboard is faster for one-off tasks like viewing a single licensee. The MCP shines when you need to batch-create licenses for ten customers, cross-reference bundle templates with active subscriptions, or automate license provisioning triggered by Slack messages or support tickets. Agents can chain multiple NetLicensing operations in one conversation without you switching tabs.
Who on the team should connect this MCP?
Whoever owns your licensing configuration — typically a product manager, DevOps lead, or founder. They'll need access to your NetLicensing vendor account to generate the API key. Once connected, anyone in your Switchy workspace can ask agents to perform licensing tasks, but the connection itself uses that single shared credential.