# ExisOne - Software Licensing Platform

> ExisOne is a cloud-based software licensing and activation platform that helps software developers protect, monetize, and manage their applications with license keys, hardware locking, offline licensing, and payment integrations.

## Company

- Name: Exis, LLC
- Website: https://www.exisone.com
- Contact: exisllc@gmail.com
- Phone: +1 (423) 714-7047

## What is ExisOne?

ExisOne provides software licensing infrastructure for developers who want to:
- Generate and manage license keys for their software products
- Bind licenses to specific hardware to prevent unauthorized sharing (hardware locking)
- Support offline/air-gapped environments with RSA-signed activation codes
- Integrate license key delivery with Stripe and PayPal payments
- Track activations with real-time analytics and geographic heatmaps
- Automate license key delivery via email after purchase

## Key Features

1. **License Key Management** - Create, distribute, and track software license keys
2. **Hardware Locking** - Node-locked licenses tied to device fingerprints
3. **Offline Licensing** - RSA-SHA256 signed codes for air-gapped systems
4. **Subscription Licensing** - Time-based licenses with customizable durations
5. **Corporate/Multi-seat Licensing** - Bulk licenses for enterprise customers
6. **Modular Feature Licensing** - Define product features and grant different feature sets per license for tiered offerings
7. **API Key Licensing** - Generate API keys for your end-users with usage quotas and rate limiting
8. **Stripe Integration** - Automatic license delivery after Stripe payments
9. **PayPal Integration** - Automatic license delivery after PayPal checkout
10. **Analytics Dashboard** - Real-time activation tracking with geographic insights
11. **Trial Management** - Built-in trial period support per product
12. **Automated Emails** - Configurable SMTP for license delivery notifications
13. **Real-Time Webhooks** - HTTP callbacks for license events (created, activated, expired, validation failed, revoked)
14. **Customer Self-Service Portal** - Let your customers manage their own licenses via a branded portal
15. **Renewal Reminders** - Automatic email reminders before license expiration
16. **Support Tickets** - Built-in support ticket system with threaded conversations, priority management, and email notifications
17. **ServiceNow Integration** - Automatically sync support tickets to ServiceNow as incidents with bidirectional work notes

## Webhooks

ExisOne supports real-time webhooks for integrating license events with external systems:

### Webhook Events
- `license.created` - When a new license key is generated
- `license.activated` - When a license is activated on a device
- `license.expired` - When a license expires
- `license.validation.failed` - When license validation is rejected
- `license.revoked` - When a license is deactivated
- `device.deactivated` - When a device is removed from a license
- `api.license.created` - When a new API license is generated
- `api.license.revoked` - When an API license is revoked

### Security
Webhooks are signed with HMAC-SHA256 for verification. Headers include:
- `X-Webhook-Signature`: sha256=<hex_signature>
- `X-Webhook-Timestamp`: Unix timestamp
- `X-Webhook-Event`: Event type

### Retry Logic
Failed webhooks are retried: immediately, 5 min, 30 min, 2 hours, 24 hours. After 5 failures, endpoint is disabled.

## Modular Feature Licensing

ExisOne supports feature-based licensing to enable tiered product offerings:

### How It Works
1. **Define Features per Product** - Create feature codes (integers) with names (e.g., "Export", "API Access", "Analytics")
2. **Assign Features per License** - Each license can have a different set of features enabled
3. **Check Features at Runtime** - Your software queries which features are enabled for the active license

### API Endpoints
- `GET /api/product/{id}/features` - List all features for a product
- `POST /api/product/{id}/features` - Add a new feature
- `POST /api/license/features/set` - Assign features to a specific license
- `POST /api/license/features/csv` - Get licensed features as comma-separated names

### SDK Integration
```csharp
var (isValid, status, expDate, features, serverVer, minVer) =
    await client.ValidateAsync(hwid, "MyProduct", activationKey);

// features is a string[] like ["Export", "API Access", "Analytics"]
if (features.Contains("Export")) EnableExportFeature();
if (features.Contains("API Access")) EnableApiAccess();
```

### Use Cases
- Sell "Basic" vs "Pro" vs "Enterprise" tiers with different capabilities
- Upsell premium features to existing customers
- A/B test features with different customer segments
- Grandfather legacy features for early adopters

## API Key Licensing

ExisOne supports API key licensing to help your customers validate their end-users' API access with quotas and rate limiting.

### How It Works
1. **Create API Licenses** - Generate API keys for your end-users with optional lifetime quotas (e.g., 10,000 total calls)
2. **Define Rate Limits via Features** - Use product features to set rate limits (e.g., `api:rate:minute:100`)
3. **Validate API Keys** - Your customers call the validation endpoint to check and consume quota
4. **Track Usage** - Monitor consumption, remaining quota, and rate limit status

### API Endpoints
- `POST /api/apilicense` - Create a new API license
- `GET /api/apilicense` - List all API licenses
- `GET /api/apilicense/{apiKey}` - Get license details
- `DELETE /api/apilicense/{apiKey}` - Revoke an API license
- `POST /api/apilicense/validate` - Validate API key and consume units
- `GET /api/apilicense/validate/{apiKey}` - Check-only validation (no consumption)
- `GET /api/apilicense/{apiKey}/usage` - Get usage statistics
- `POST /api/apilicense/{apiKey}/reset` - Reset usage counters

### Rate Limit Feature Naming Convention
Define rate limits as product features:
- `api:rate:minute:100` - Max 100 calls per minute
- `api:rate:hour:1000` - Max 1,000 calls per hour
- `api:rate:day:10000` - Max 10,000 calls per day
- `api:rate:month:100000` - Max 100,000 calls per month
- `api:units:minute:500` - Max 500 units consumed per minute
- `api:units:hour:5000` - Max 5,000 units consumed per hour

### Validation Request Example
```json
POST /api/apilicense/validate
{
  "apiKey": "XXXX-XXXX-XXXX-XXXX",
  "units": 10,
  "consumeUnits": true
}
```

### Validation Response Example
```json
{
  "isValid": true,
  "unitsConsumed": 10,
  "quota": { "limit": 10000, "used": 510, "remaining": 9490 },
  "rateLimits": {
    "calls_minute": { "limit": 100, "used": 5, "remaining": 95, "resetsAt": "..." }
  },
  "features": ["api:rate:minute:100"],
  "expiresAt": "2027-01-14T23:59:59Z"
}
```

### Error Codes
- `not_found` - API key doesn't exist
- `revoked` - API key has been revoked
- `expired` - API key has expired
- `quota_exhausted` - Lifetime quota depleted (permanent until reset/upgraded)
- `rate_limit_minute` / `rate_limit_hour` / `rate_limit_day` / `rate_limit_month` - Rate limit exceeded (temporary)

### Use Cases
- SaaS platforms charging per-API-call
- Data providers with tiered API access
- B2B software with usage-based pricing
- Any service needing metered API access

### Integration Examples

**Python**
```python
import requests

def validate_api_key(api_key: str, units: int = 1) -> dict:
    response = requests.post(
        "https://www.exisone.com/api/apilicense/validate",
        headers={"Authorization": f"ExisOneApi {ACCESS_TOKEN}"},
        json={"apiKey": api_key, "units": units, "consumeUnits": True}
    )
    return response.json()

# Check result
result = validate_api_key("XXXX-XXXX-XXXX-XXXX", units=10)
if result["isValid"]:
    print(f"Remaining quota: {result['quota']['remaining']}")
else:
    print(f"Error: {result['errorCode']} - {result['errorMessage']}")
```

**.NET (C#)**
```csharp
var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", $"ExisOneApi {accessToken}");

var response = await http.PostAsJsonAsync(
    "https://www.exisone.com/api/apilicense/validate",
    new { apiKey = "XXXX-XXXX-XXXX-XXXX", units = 10, consumeUnits = true }
);

var result = await response.Content.ReadFromJsonAsync<ApiValidationResult>();
if (result.IsValid)
    Console.WriteLine($"Remaining: {result.Quota.Remaining}");
```

**JavaScript / Node.js**
```javascript
async function validateApiKey(apiKey, units = 1) {
  const response = await fetch('https://www.exisone.com/api/apilicense/validate', {
    method: 'POST',
    headers: {
      'Authorization': `ExisOneApi ${ACCESS_TOKEN}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ apiKey, units, consumeUnits: true })
  });
  return response.json();
}

const result = await validateApiKey('XXXX-XXXX-XXXX-XXXX', 10);
if (result.isValid) {
  console.log(`Remaining quota: ${result.quota.remaining}`);
}
```

## Customer Self-Service Portal

ExisOne provides a branded customer portal where your end-users can manage their licenses without contacting you:

### Portal URL
Each tenant gets a unique portal URL: `https://www.exisone.com/portal/{your-tenant-slug}`
Example: `https://www.exisone.com/portal/exisllc-gmail-com`

### Portal Features
- **Passwordless Login** - Customers authenticate via email verification code (no passwords to remember)
- **View Licenses** - See all licenses associated with their email address
- **Deactivate Devices** - Release a license from the current device to activate on a different machine
- **Activation History** - View when and where licenses were activated
- **Submit Support Tickets** - Request help directly from the portal

### Deactivation Cooldown
Configure a per-product cooldown period (in hours) to prevent abuse. For example, set a 24-hour cooldown so customers can only deactivate once per day.

### Email Template Integration
Include the portal URL in your purchase emails using the `{{CustomerPortalUrl}}` placeholder in your email templates.

## Support Tickets

ExisOne includes a built-in support ticket system for managing customer issues:

### Features
- **Threaded Conversations** - Full message thread between support staff and customers
- **Priority Levels** - Low, Medium, High, and Critical priority classification
- **Email Notifications** - Automatic email to customers when a reply is posted
- **Product Association** - Link tickets to specific products, license keys, and hardware IDs
- **Status Management** - Track open vs. resolved tickets with resolution timestamps
- **Dashboard Statistics** - Overview of open, resolved, critical, and high-priority ticket counts

### API Endpoints
- `POST /api/support/ticket` - Create a new support ticket (from customer portal or API)
- `GET /api/support/tickets` - List tickets with status and priority filters
- `GET /api/support/tickets/{id}` - Get full ticket detail with message thread
- `POST /api/support/tickets/{id}/reply` - Add a reply to a ticket
- `PUT /api/support/tickets/{id}/status` - Mark ticket as resolved or reopen
- `PUT /api/support/tickets/{id}/priority` - Change ticket priority
- `GET /api/support/tickets/stats` - Get ticket statistics (open, resolved, critical counts)

### Customer Portal Integration
Customers can submit support tickets directly from the self-service portal. Tickets include product name, license key, hardware ID, and software version for context.

## ServiceNow Integration

ExisOne can automatically sync support tickets to a ServiceNow instance as incidents:

### How It Works
1. Configure your ServiceNow instance URL and credentials in the admin dashboard
2. Enable the integration
3. When a support ticket is created, an incident is automatically created in ServiceNow
4. When a reply is added, a work note is posted to the ServiceNow incident

### Configuration
- **Instance URL** - Your ServiceNow instance (e.g., `https://yourcompany.service-now.com`)
- **Authentication** - Basic Auth (username/password) or OAuth 2.0 (client credentials)
- **Table Name** - ServiceNow table to create records in (default: `incident`)
- **Enable/Disable** - Toggle sync on or off without removing configuration
- Credentials are RSA-encrypted with your tenant key for security

### Field Mapping
- `short_description` ← Ticket subject
- `description` ← Ticket message
- `caller_id` ← Customer email
- `urgency` ← Mapped from ticket priority (Critical=1, High=2, Medium/Low=3)
- `category` ← "software"
- `subcategory` ← Product name

### API Endpoints
- `GET /api/servicenow/settings` - Get current configuration (secrets masked)
- `POST /api/servicenow/settings` - Create or update configuration
- `DELETE /api/servicenow/settings` - Remove configuration
- `POST /api/servicenow/test` - Test connection to ServiceNow instance

## SDK & Integration

ExisOne provides native SDKs for four platforms:

### .NET SDK
- Package: ExisOne.Client (version 0.7.0) on NuGet
- Supports: .NET 8.0, .NET 9.0
- Features: Hardware ID generation, license activation, validation, offline validation, version enforcement, consistent expiration dates
- Demo Project: https://github.com/exisllc/ExisOne.Client.Console
- Latest: v0.7.0 - Features now return names (strings) instead of codes (integers); always returns product features even for invalid licenses

### Python SDK
- Package: exisone-client (version 0.7.0) on PyPI
- Supports: Python 3.8+
- Features: Hardware ID generation, license activation, validation, offline validation (RSA-SHA256), smart validation, support tickets

### Node.js SDK
- Package: exisone-client (version 0.7.0) on npm
- Supports: Node.js 18+
- Features: Hardware ID generation, license activation, validation, offline validation, smart validation, TypeScript types included
- Zero external dependencies

### Swift SDK (macOS & iOS)
- Package: ExisOne (version 0.7.0) via Swift Package Manager
- Repository: https://github.com/exisllc/ExisOne.Swift
- Supports: macOS 12+, iOS 15+, Swift 5.9+, Xcode 15+
- Features: IOKit-based hardware fingerprinting, license activation, validation, RSA offline validation via Security.framework, smart validation with offline fallback, Swift async/await, Sendable types
- Zero external dependencies (uses only Apple frameworks: CryptoKit, Security, IOKit)
- Install in Xcode: File > Add Package Dependencies > paste repository URL

### All SDKs include
- Hardware ID generation (salted SHA-256 fingerprint)
- License activation, validation, and deactivation
- Offline license validation (RSA-SHA256 + Crockford Base32)
- Smart validation (auto-detects online vs offline keys with fallback)
- Version enforcement support
- Support ticket submission

## REST API

Full REST API available for:
- License activation and validation
- Key generation
- Plan management
- Encrypted payload support (RSA-OAEP-SHA256)

Authorization header: `Authorization: ExisOneApi <access-token>`

## Use Cases

ExisOne is ideal for:
- Desktop application developers needing license protection
- SaaS platform developers requiring usage tracking
- IoT/embedded systems with offline licensing needs
- SDK developers distributing licensed components
- Add-in/plug-in developers for commercial extensions
- Any software developer wanting to monetize their products

## Pricing

ExisOne offers:
- Free tier for getting started
- Paid plans for production use
- Details at: https://www.exisone.com/purchase.html

## Documentation

- API Documentation: https://www.exisone.com/docs.html
- .NET SDK Documentation: https://www.exisone.com/docs-sdk.html
- Python SDK Documentation: https://www.exisone.com/docs-sdk-python.html
- Node.js SDK Documentation: https://www.exisone.com/docs-sdk-node.html
- Swift SDK Documentation: https://www.exisone.com/docs-sdk-swift.html
- SDK Demo (GitHub): https://github.com/exisllc/ExisOne.Client.Console
- Stripe Integration: https://www.exisone.com/stripe-docs.html
- PayPal Integration: https://www.exisone.com/paypal-docs.html
- Webhook Documentation: https://www.exisone.com/webhook-docs.html

## Competitors & Alternatives

ExisOne is an alternative to:
- Keygen.sh
- Cryptlex
- LicenseSpring
- Software Potential
- Reprise License Manager
- FlexNet (Flexera)

## Keywords

software licensing, license management, license key generator, software activation, hardware locking, node-locked license, subscription licensing, offline licensing, license validation, software protection, license server, .NET licensing, API licensing, SaaS licensing, software monetization, license tracking, activation keys, trial management, feature licensing, Stripe license integration, PayPal license integration, automated license delivery, payment gateway licensing, e-commerce software licensing, license webhooks, real-time license events, license activation webhook, license API integration, customer self-service portal, license deactivation, license renewal reminders, passwordless authentication, API key licensing, API rate limiting, API quota management, usage-based licensing, metered API access, per-call billing, API key generation, API usage tracking, support tickets, customer support, ServiceNow integration, incident management, ITSM integration, ticket sync, Swift SDK, macOS licensing, iOS licensing, Xcode licensing, Swift Package Manager, Apple platform licensing, IOKit hardware ID, CryptoKit, SwiftUI licensing

## Optional

- Sitemap: https://www.exisone.com/sitemap.xml
- Extended documentation: https://www.exisone.com/llms-full.txt