LicenseSpring-MCP: Multi-Subscription & Authentication MCP Integration Tool 解析：核心关键词为“licensespring-mcp”和“MCP集成工具” ，卖点是“支持多订阅与认证”。英文标题以产品名开头，直接点明核心产品，接着说明其具备多订阅与认证功能的MCP集成工具属性，简洁清晰，符合英文表达习惯且在长度要求内。

Licensespring MCP

The LicenseSpring MCP server implementation provides complete license management and customer operation functions, including license activation, customer management, usage tracking, etc., supporting multiple subscription levels and authentication methods.

Developer tools Security #License management #Customer management #Usage tracking #Floating license .TypeScript

rating : 2.5 points

downloads : 4.8K

update time : 2025-07-24

Open Site

What is the LicenseSpring® MCP Server?

The LicenseSpring® MCP Server is an MCP server implementation integrated with the LicenseSpring API, providing complete license management, customer operation, and usage tracking functions. It supports multiple license types (such as floating licenses and trial licenses) and provides a secure API authentication mechanism.

How to use the LicenseSpring® MCP Server?

By configuring the LicenseSpring API key and shared key, you can quickly start the MCP server and deploy it via the command line or Docker container. The server supports multiple development tools, including VS Code and Claude Desktop.

Use cases

Suitable for enterprises and individual developers who need to manage software licenses. Whether it's activating, checking, or managing licenses, it can be easily done through this server.

Main features

License operations

Supports activating, checking, and deactivating licenses, and can bind hardware IDs to enhance security.

Customer management

Can create, list, and manage customer information, facilitating customer classification and tracking.

Usage tracking

Monitors license usage and feature usage frequency to help optimize resource allocation.

Trial license management

Generates and manages trial licenses to provide customers with a risk - free trial experience.

Floating license support

Supports operations for floating licenses, allowing flexible use on multiple devices.

Multiple authentication methods

Prioritizes the use of LICENSE_API_KEY and also supports LICENSE_SHARED_KEY as an additional security measure.

Advantages

Supports multiple license types to meet different business needs.

Provides detailed usage tracking and analysis functions.

Easy to integrate into existing development processes, supporting tools such as VS Code and Claude Desktop.

Has a complete test suite to ensure stable and reliable functionality.

Limitations

Some advanced features may require an upgrade to the Premium or Enterprise subscription level.

Some functions are restricted in the Basic or Standard subscription levels.

Requires a certain technical background to configure and use API keys.

How to use

Get API keys

Install the MCP server

Globally install the LicenseSpring MCP server package using NPM or pull the Docker image.

Configure environment variables

Set the LICENSE_API_KEY and LICENSE_SHARED_KEY (optional) according to your subscription level.

Start the MCP server

Run the MCP server and select the License API or Management API mode.

Usage examples

Activate a license

The user enters the license key and hardware ID, and the system automatically activates the license.

Generate a trial license

Provide a trial license for new users, allowing them to use the product for free within a limited time.

Manage customer information

Enterprise administrators can create and update customer information to better track customer activities.

Frequently Asked Questions

How to get the License API key?

What should I do if I encounter authentication failure?

Which development tools does the MCP server support?

How to update the MCP server?

Why can't my license be activated?

Related resources

LicenseSpring official documentation

Detailed documentation and instructions about the LicenseSpring API.

GitHub project repository

The source code and release versions of the LicenseSpring MCP server.

Installation guide video tutorial

A video tutorial on how to install and configure the LicenseSpring MCP server.

🚀 LicenseSpring® MCP Server

An MCP server implementation integrating with LicenseSpring APIs, offering comprehensive license management and customer operations capabilities.

🚀 Quick Start

The LicenseSpring® MCP Server is an implementation that integrates with LicenseSpring APIs, providing comprehensive license management and customer operations capabilities.

✨ Features

License Operations: Activate, check, and deactivate licenses with hardware binding.
Customer Management: Create, list, and manage customers.
Usage Tracking: Monitor license consumption and feature usage.
Trial Management: Generate and manage trial licenses.
Floating Licenses: Handle floating license operations.
Authentication Priority: Use LICENSE_API_KEY as the primary method, and LICENSE_SHARED_KEY is optional for enhanced security.
Comprehensive Testing: A full - scale integration test suite validates against the real API.

📦 Installation

NPM Package

npm install -g @tfedorko/licensespring-mcp-server

Note: Requires Node.js 20.x or higher for optimal compatibility.

Docker Images

# License API Server
docker pull stiertfedorko/licensespring-mcp:latest

# Management API Server
docker pull stiertfedorko/licensespring-mcp-management:latest

💻 Usage Examples

Usage with Claude Desktop

License API Server

{
  "mcpServers": {
    "licensespring": {
      "command": "npx",
      "args": [
        "-y",
        "@tfedorko/licensespring-mcp-server",
        "license-api"
      ],
      "env": {
        "LICENSE_API_KEY": "YOUR_LICENSE_API_KEY",
        "LICENSE_SHARED_KEY": "YOUR_SHARED_KEY_IF_USING_SHARED_API_SETTINGS"
      }
    }
  }
}

Management API Server

{
  "mcpServers": {
    "licensespring-management": {
      "command": "npx",
      "args": [
        "-y",
        "@tfedorko/licensespring-mcp-server",
        "management-api"
      ],
      "env": {
        "MANAGEMENT_API_KEY": "YOUR_MANAGEMENT_API_KEY"
      }
    }
  }
}

Docker

{
  "mcpServers": {
    "licensespring": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "LICENSE_API_KEY",
        "-e",
        "LICENSE_SHARED_KEY",
        "stiertfedorko/licensespring-mcp:latest"
      ],
      "env": {
        "LICENSE_API_KEY": "YOUR_LICENSE_API_KEY",
        "LICENSE_SHARED_KEY": "YOUR_SHARED_KEY_OR_LEAVE_EMPTY"
      }
    },
    "licensespring-management": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "MANAGEMENT_API_KEY",
        "stiertfedorko/licensespring-mcp-management:latest"
      ],
      "env": {
        "MANAGEMENT_API_KEY": "YOUR_MANAGEMENT_API_KEY"
      }
    }
  }
}

Usage with VS Code

One - click Installation

For quick installation, use the one - click installation buttons below:

Manual Installation

{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "license_api_key",
        "description": "LicenseSpring License API Key",
        "password": true
      },
      {
        "type": "promptString",
        "id": "license_shared_key",
        "description": "LicenseSpring Shared Key (optional for Basic/Standard tiers)",
        "password": true
      }
    ],
    "servers": {
      "licensespring": {
        "command": "npx",
        "args": ["-y", "@tfedorko/licensespring-mcp-server", "license-api"],
        "env": {
          "LICENSE_API_KEY": "${input:license_api_key}",
          "LICENSE_SHARED_KEY": "${input:license_shared_key}"
        }
      }
    }
  }
}

📚 Documentation

Configuration

Getting API Credentials

License API Key: Log into your LicenseSpring dashboard → Settings → Keys (PRIMARY authentication method).
Management API Key: Same location, copy your Management API Key.
Shared Key: Optional for organizations using shared API settings (provides enhanced security).

Testing

# Build the project
npm run build

# Run integration tests against real LicenseSpring API
npm run test:integration

# Run unit tests
npm test

The integration test validates all 34 MCP tools against the real LicenseSpring API and verifies authentication priority works correctly. The implementation provides 100% feature parity with the LicenseSpring Postman collection.

🔧 CI/CD Integration: GitHub Actions workflows now support full integration testing with proper secret configuration.

Subscription Tier Support

The server automatically adapts to your LicenseSpring subscription tier:

Premium/Enterprise: Full functionality with HMAC authentication.
Basic/Standard: Limited mode with helpful upgrade guidance.
Development: Test mode for safe development.

Note: LICENSE_SHARED_KEY is optional. The server will start regardless of your subscription tier and provide appropriate guidance for API limitations.

Troubleshooting

Common Issues

Error: "npm error could not determine executable to run"
- Solution: Update to version 1.0.1 or later: npx @tfedorko/licensespring-mcp-server@latest.
- Cause: Fixed in v1.0.1 - improved binary configuration and startup process.
Error: "MCP error -1: Connection closed"
- Solution: Update to version 1.0.2 or later: npx @tfedorko/licensespring-mcp-server@latest.
- Cause: Fixed in v1.0.2 - server now defaults to license - api mode for Claude Desktop compatibility.
Error: "LICENSE_API_KEY is required"
- Solution: Set your environment variables in .env file or Claude Desktop config.
- Check: Copy .env.example to .env and fill in your API credentials.
Error: "Authentication failed"
- Solution: Verify your API keys in the LicenseSpring dashboard.
- Note: LICENSE_SHARED_KEY is optional for Basic/Standard subscription tiers.
Server starts but API calls fail
- Check: Your LicenseSpring subscription tier and available API features.
- Solution: The server provides helpful guidance for subscription limitations.

Getting Help

Check the error messages - they provide specific guidance.
Verify your LicenseSpring subscription tier and API access.
Review the Advanced Documentation below.
Open an issue on GitHub with error details.

Release Automation

Quick Release Commands

npm run release          # Patch release (1.0.0 -> 1.0.1)
npm run release:minor    # Minor release (1.0.0 -> 1.1.0)
npm run release:major    # Major release (1.0.0 -> 2.0.0)

Preview Changes

npm run version:dry      # Preview version bump
npm run publish:dry      # Preview NPM publish

Automated GitHub Releases

Commit triggers: Use [release] in commit messages.
Manual dispatch: GitHub Actions workflow.
Semantic release: Conventional commit messages.

For complete automation documentation, see Release Automation Guide.

Advanced Documentation

Release Automation Guide - Complete automated release and distribution system.
Subscription Tier Support - Detailed guide for different LicenseSpring subscription tiers.
Distribution Guide - Complete setup and sharing instructions.
Test Report - Comprehensive testing results and validation.
Migration Guide - Technical implementation details.

Tools

License API Tools

Tool Name	Description
`activate_license`	Activate a license with hardware ID binding.
`check_license`	Check license status and validity.
`deactivate_license`	Deactivate a license for specific hardware.
`add_consumption`	Add consumption units to a license.
`get_trial_key`	Generate trial license keys.
`get_product_details`	Retrieve product information.
`floating_release`	Release floating licenses.
`floating_borrow`	Borrow floating licenses for offline use.
`change_password`	Change user passwords for user - based licenses.
`get_versions`	Get available software versions.
`get_installation_file`	Get installation file information.
`get_sso_url`	Generate Single Sign - On URLs.

Management API Tools

Tool Name	Description
`list_licenses`	List licenses with optional filtering.
`create_license`	Create new licenses.
`update_license`	Update existing licenses.
`get_license`	Get detailed license information.
`delete_license`	Delete licenses.
`list_customers`	List customers with filtering options.
`create_customer`	Create new customers.

📄 License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.