Blog on Software Licensing, Commercialization, and Revenue Optimization

New AI feature helps optimize software pricing

Setting the price for a product you intend to sell is hard, especially when pricing usually changes over time. Cryptolens’ new AI feature helps software providers set the price by analyzing how each individual user uses their software.

Problem with existing pricing models

It is often challenging for software providers to price their product optimally.

A good example that demonstrates this is when you set the price for accounting software. Imagine you have two groups of customers: those that use the software regularly in their profession (eg. accountants helping other companies) and those that only use it once a month (eg. small businesses). It makes sense to have different pricing models for these two groups: professionals can be charged monthly (and are very likely to pay more) and the smaller business can pay per usage (eg. per generated monthly report).

As a result, software providers are able to increase their revenues and capture both customer groups by taking into account the true value the software has for each group, and adjusting the pricing model to meet the needs for each group.

How Cryptolens’ new AI feature optimizes revenue

Cryptolens’ new AI feature analyzes the usage information generated by each user (and the history from previous users) and determines the value a product (and its features) has for each user, and then helps to determine the best pricing model for that particular user or user group.

For example, if the value of the features is higher than the price of the product, it would be reasonable to increase the price. If, however, only a subset of the product’s features are used, a new product based on a subset of the features offered at a lower price could be a solution (or potentially suggest an alternative licensing model such as usage-based model).

The goal is to provide insights on the value of a product and its features for each user, and assist in creating new product offerings with more optimal pricing.

Getting started

In order to benefit from our AI analysis, the following is required:

First, you need to register each time a customer interacts with a certain feature of the product (if you have a licenseKey object, you can call the new RegisterEvent method). For example, when they start the salary module (if it’s an accounting software), you can send FeatureName=”SalaryModule” and EventName=”start”. If they generate a report, you can keep the feature name, but change the event name to “report_generated”.

The second step is to register successful transactions (eg. when the customer buys the software). In that case, you can still call RegisterEvent method, and include the value and currency parameters.

Please get in touch with us if you need any help setting this up. We are currently looking for beta testers and would be happy if you can participate. You can reach out to us at support@cryptolens.io.

Once enough data is collected, you will be able to see it in the analytics dashboard.

Floating licenses supported out of the box

Floating licenses allow your customers to use a license on a limited number of machines simultaneously. For example, they can have your software installed on 100 computers, but only be able to use it on 20 of them at once.

This is similar to node-locked licenses (aka machine code locking) that is part of the Cryptolens for quite some time, with the exception that a license does not have to be deactivated when they are to be used on a new device.

Note: floating licenses are supported since v405 of Cryptolens.Licensing library for .NET. Support for C++ is coming soon.

Examples

Cryptolens Licensing for .NET (new package)

You might have noticed that we have changed from being called Serial Key Manager to Cryptolens. As a result, the design language, domains and naming of our products has changed. Now, we are also updating the .NET packages that are used to interact with the Web API. We will describe the changes below (you can also see the release notes)

New package

The new package, Cryptolens.Licensing, is essentially the same as SKGLExtension, with several improvements described below. You can either install it using NuGet or download pre-compiled binaries for the desired framework. Read more here.

.NET Standard

The new library introduces support for .NET Standard 2.0, which means more platforms in the .NET family can use it (eg. .NET Core 2.0). You can see all the supported platforms here. There is still support for .NET Framework 4.0, although most of the new features will be in the .NET Framework 4.6.

License verification on the server

Previously, most of the license validation logic was performed on the client, eg. you had to check expiration, features in the client code. The new Cryptolens client now supports the ability to create rules and perform these checks on the server. The rules are set up using feature definitions on the product page. You only need to set Metadata=True, which will give you access to the license key status. A code example is shown below (this will automatically check that the key has not expired and that it’s not blocked).

var result = Key.Activate(activateToken, new ActivateModel() 
{
    Key = "license",
    ProductId = 3349, 
    Sign = true, 
    Metadata=true
});

if(result.Metadata.LicenseStatus.IsValid)
{
    Console.WriteLine("License is valid!")
}

A good practise is to verify the signature of this license status object, which can be done with VerifySignature. At the moment, this requires .NET Framework 4.6 or .NET Standard 2.0 to work.

3 steps how to protect your software application before release

Let’s assume that you have developed a software application (eg. app) that you are about to sell. Then, there are three things you need to consider:

  • Licensing – this is used to keep track of the type of features that end users have bought. A simple example of this when your user has to type a license key to unlock more functionality. When selecting these kinds of systems, it’s important that the system both supports offline mode and is cloud-based. The advantage of cloud-based systems is that they are more scalable and secure (eg. you have full control of all end users).
  • Obfuscation – this is used to make your program binaries (eg. exe and dll files) harder to disassemble. This is especially important for .NET apps, since existing tools make this very simple. A word of warning though: none of the available systems are 100% safe, and even the well-respected systems are being cracked within days of software release.
  • Web API – imagine your algorithm is so important that you don’t want to risk it being leaked. Since obfuscators are never 100% safe (mainly because in the end, the code will be executed on the client machine), the only secure way is to never run this code on client machines that you don’t control. Instead, you can create a Web API method that you host yourself and then allow your program to consume it. In this case, the algorithm is safe at the cost of constant internet access requirement.

To sum up, the first system to consider is licensing, since this will remove the administrative burden of keeping track of the type of rights your customers have to the software. As a bonus, many cloud-based licensing systems support integration with payment processors. In the end of the day, the goal is to ensure payments and license verification are automated, so that you can focus on developing the features that really matter to your customers.

For more information, please see this page.

New Analytics Dashboard for Software License Management

Today, we are happy to share a new version of the analytics dashboard (available to all customers), which includes many new cool features. We will sum this up in this post. The new analytics dashboard will be improved continuously, with the aim to offer more in-depth analysis of the data.

If you have any feedback, we would be happy to hear from you!

Getting Started

  1. Login on your account: https://app.cryptolens.io/Account/Login
  2. Go to https://app.cryptolens.io/Stats
  3. Click on the link on the top of the page to visit the new page.

Note: After a while, the new page (https://analytics.cryptolens.io/index.html) will redirect you back to the old page. To view it again, you just need to click on the link again. We will fix this in the coming weeks.

Feature Walkthrough

World Map and Filters (by country)

To start with, you will see all the data that has accumulated since the beginning (“all time” option). You can control this easily with the 5 buttons available in the top menu (we will discuss how to set a custom time period a bit later).

The map allows you to examine stats from specific regions. You can select the desired countries and then click on “show/hide filters” and click on the “filter” button close to the country tags, as shown below (filtering on Sweden and Norway). Once we have activated the filter, it will turn blue. You can then click on the filter again and it will turn white, meaning it’s no longer active.

Timeline

If you are interested in a different time region than those supported on the top menu, you can use the timeline to select an area of interest. To reset the timeline, just double-tap on it.

Time of Day

One way to understand how your application is being used is by examining when it’s used during the day. This was already available in the old analytics dashboard. The key difference in the new one is that it takes into account the local time zone of the end user.

Most Active Customers and Other Metrics

The last part includes a short summary of the key metrics such as how many licenses were created and how many requests were made during a specific time period. Moreover, it’s now also possible to compare “how active” license keys and customers are relative to each other. For instance, in the customer list, you can see your top most active and inactive customers, which can help you to discover the early adopters in a technology adoption lifecycle model.

User Accounts instead of License Keys

The common way of distributing licenses has always been using license keys (or files). Each time a customer needs more features, they have to get a new license key. Thanks to a cloud-based solution such as SKM, it’s possible to limit the number of licenses a customer needs to keep track of, since you can always change the properties of a license in the control panel.

With the “user login authentication” feature, we want to take distribution of licenses a step further and make it even more seamless for you and your customers. Below are some of the benefits of using user login authentication:

Benefits of User Login Authentication

  • Security – an account is much easier to protect than a license key (SKM has many security mechanisms in place, including two-factor authentication).
  • Time – if your customer loses a license key, they will first of all contact you, which will require more maintenance time per customer (SKM account can always be restored automatically and if more support would be needed, we will take care of it).
  • Trust – every user account comes with an easy-to-use control panel that makes it easier for your customers to manage their licenses.

Getting Started

A quick way to get going with user login authentication is by watching a short video and reviewing an example implementation on GitHub.

Note: In addition to SKM Client API, you need to install Cryptolens.SKM, which requires .NET Framework 4.6.2 or above (or .NET Core 1.0 or above). Cryptolens.SKM targets .NET Standard 1.4, so if you target any other .NET friendly platform, you can find more information here.

If you have any feedback or suggestions, please contact us at support (at) skmapp.com.

Useful Facts & Links

New Client API for C++

We have now finalized the last bits that were left to make the C++ client API more reliable and easier to integrate. This is great news if you develop applications in C++ (for instance, drivers, connected products as a service, IoT products, and more).

Right now, it offers the activation method, which is the method that should always be called to either verify or activate a license. If there are other methods that you would find useful, please get in touch with us.

The project has been lead by Martin Svedin, Lead Developer.

On the technical side

Our client API in C++ is quite different from its .NET counterpart. The main difference is in error handling, the protocol under the hood and the ability to perform API requests outside of our API (which uses curl by default). Extensions functions (ability to chain together several constraints together) in the C++ client are similar to the .NET client.

How to perform activation

In the .NET client, the only object you need is LicenseKey. In the C++ client, there is a similar class called LicenseKey (which contains license key parameters such as features). However, in order to retrieve a LicenseKey object, you cannot just call the activation method. Instead, you need to use an intermediate class called RawLicenseKey. That is, when you call the activation function, it will return a RawLicenseKey, which can be used to create a LicenseKey object.

The only difference between RawLicenseKey and LicenseKey is that the former one contains signature whereas the latter one does not. If you want to support offline activation, you should save RawLicenseKey object (the license and the signature, as described here). However, when you verify the license parameters, LicenseKey should be used instead.

Adding constraints

Adding a chain of constraints on LicenseKey object is very similar to the way it is done in .NET. For example, in .NET, to check that feature 1 is enabled and the key has not expired, you would type:

licenseKey.HasNotExpired().HasFeature(1).IsValid() // returns true if the constraints are satisfied

In the C++ client, it’s quite similar:

license_key->check()->has_not_expired(123456789)->has_feature(1) // returns true if the constraints are satisfied

A minor difference is that has_not_expired requires the current time as a Unix time stamp in seconds.

Public Key extraction

Another point worth mentioning is how you insert your public key (not the access token) into the C++ client. You can find your RSA public key here that has a structure similar to the one below:

<RSAKeyValue><Modulus>sGbvxwdlDbqFXOMlVUnAFgteQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>

When you specify the modulus and exponent, you can just copy them directly from your public key as shown below:

skm_handle.signature_verifier.set_modulus_base64(e, "sGbvxwdlDbqFXOMlVUnAFgteQ==");
skm_handle.signature_verifier.set_exponent_base64(e, "AQAB");

This has to be done before any activation request is sent, as shown here.

Summary

This was a short summary of the C++ client, with focus on users that are familiar with our .NET client. For further information, please see the GitHub repository and API documentation Please get in touch with us should you have any questions! One more thing, please review the third party licenses when you are ready to release your application.

We’ve updated the license agreement to comply with GDPR

This week we’ve updated our terms of use, which now includes a new separate document (named Agreement) that clarifies the way your data is processed. In addition, we have also changed the party that provides the service, which is now Cryptolens AB. General Data Protection Regulation (GDPR) will be enforceable May 25th, 2018.

Important Considerations

When your customers are running your application, personal information such as the IP address is sent to Cryptolens AB. GDPR aims to protect users’ privacy, which means that it is important that you have a consent from your customers in doing so.

To make sure that you are compliant, our lawyer has composed an excerpt that you can insert into your agreement.

Binding the agreement to your customers

If you are targeting a large number customers, it may not be feasible to get a signed copy of the agreement. Instead, there are several ways you can make it binding online. We have listed several suggestions below:

  1. Before your customers can use your application, they should have opened a window that shows the Terms of the agreement (if you have your own end user license agreement) together with the Consent to personal data processing.
  2. It must be ensured that your customers have read the documents before they can use your application. There are different ways to do this and a function with a non-pre-filled box can be used. The customer must actively tick the box to approve the Terms of the agreement and the Consent to personal data processing.

If you would have any questions, please feel free to contact us.

Updating pricing for better accessibility

Several days ago, we updated our pricing page with the aim of making SKM more customized to your business needs. Before, we had three types of subscriptions, but we quickly realized that all our customers had different requirements of the set of tools they need (eg. licensing, payments and analytics). Therefore, we want to focus on giving you the tools that better satisfy your requirements.

This means that we will use a usage based licensing model where you only pay for the modules you use and their usage. However, we also plan to introduce a standard pricing tier that can be used by those without specific requirements. This is coming soon, already in the beginning of next month. Using this approach, we hope that we can help both early stage startups as well as larger enterprises with custom needs.

In general, this change will increase the price of our core licensing offering. This only affects customers that registered a subscription in 2017 (i.e. those of you who had a subscription before 2017 will not be affected). We understand that this can have an impact on your plans, which is why we have developed a general procedure of how this change is implemented:

  • If your subscription is about to expire (or has expired), you will get up to 3 months for the same price as before.
  • Within those 3 months, we will give you an offer based on your needs.
  • In specific cases, we are ready to adjust the rules above (eg. generally for start ups and/or students).

The reason behind the changes is because SKM has evolved from being a hobby-project into a real company. This means that we can invest into better infrastructure, focus on upgrades and new features, and be able to provide a system that is compliant with various types regulations (for example, we are already GDPR compliant).

But most importantly, our goal is to ensure that you can focus on the core features of your application, and not have to think about licensing and payments.

For example, we have recently released support for platforms using C++, new Web API methods and many other updates. In the coming week, we will release even more visible changes, such as the “User Login Authentication” project, which is a new and more secure way of licensing applications. Please keep visiting our blog for more information.

To sum up, we do everything we can to stay innovative and provide you with a modern licensing system that you can rely on.

/Artem

New version of SKM Client API, 4.0.2

Today we’ve released a new major version of SKM Client API for .NET. The important takeaway from our release notes is that we have have fixed the networking issue with applications running in a corporate environment (eg. VPN) and those running through a proxy. This is good for those of you that develop enterprise applications. Moreover, we’ve brought support for SHA-256, which is now the default hash function for machine codes.