Blog on Software Licensing, Commercialization, and Revenue Optimization

Start countdown upon activation

Welcome! This blog will cover our feature called “Start countdown upon activation”, which is also referred to as “Trial Activation”. We will first go through when this feature is useful in theory, we will then cover a basic setup, followed by a more advanced use case for when you allow multiple machines to use the same license. Please read our documentation page for more information.

Please watch the video below if you would rather take in this information as a video:

In theory

Let’s suppose that we have a time-limited license issued today that should be valid for 30 days. Normally, the countdown will begin as soon as the license is created. However, this can be problematic if you want to create a list of licenses before they reach your customers, and you are unsure when your customers will activate their licenses.

Ideally, you want the license to be valid for 30 days after the customer has activated the license, and not 30 days after you created the licenses. That is where the feature we will cover today comes in handy.

Basic setup

For the basic setup, we will cover an example where you want to create a time-limited license limited to one machine only, and you want the countdown to begin upon activation.

Sign in to Cryptolens and create a license key as you normally do by pressing the blue “Create a new key” button for your desired product.

In the red bottom right card, you will see a checkbox called “Start countdown upon activation”. Please click this checkbox and click on Create.

Make sure you always click that checkbox for all of the licenses you create where you want the countdown to begin only when the customer activates their license.

Advanced use case

What if we want to start the countdown of a license upon activation for a license that is limited to more than one machine?

With the basic setup, each new activation will reset the countdown. Let’s say that you have set up a license that is limited to 30 days. If your customer activates the license on one machine, waits seven days, and activates the license on another machine, the license will be valid for another 30 days, meaning it will be valid for 37 days in total from the date when your customer activated the license on the first machine.

If you allow for more than two machines, this phenomenon can then naturally happen more than once, and the license might be valid for even longer.

Using data objects, you can make sure that only the first machine will activate the countdown, and that the other machines will not affect or reset the countdown.

Go to the product you want to implement this feature on. Click on “Data Objects”.

Copy the following code and paste it into the “Name” field:

cryptolens_trialactivation

Copy the following code and paste it into the “StringValue” field:

first_activation

For the chosen product, the countdown will now be activated the first time a customer activates the license on a machine, but new machines will not affect the behavior of the countdown at all.

We are happy to answer any questions you might have! Send them either to our chat support or email the questions to [email protected].

Thank you for reading!


Get Started with Cryptolens Today!

Choosing between floating and node-locked licenses

Companies often face a challenge when choosing between floating and node-locked licenses. The two licensing models both handle the issue of setting a maximum number of machines that can use a license key at the same time. However, there are significant differences.

The main benefits of each model will be explained in this blog. You can also watch the following video on YouTube:

Floating and Node-locked licenses

For the node-locked licensing model, let us assume that your client uses your license key on Machine A and B. If you want to activate Machine C, you first have to deactivate either A or B.

Floating licenses instead allow you to put a constraint to only allow, for example, 10 machines to use the license at the same time. The client can then install the application on, for example, 100 machines, but only be able to have 10 machines use the license key at the same time.

Floating licenses are therefore better if you know in advance that your customer will be moving machines and the most important aspect for you is that they do not use the license on more than a set number of machines.

Node-locked licenses are then best if you know that a customer will only use the license on a specific set of machines, and given that they will not switch machines often.

We hope we have now answered the question “Choosing between floating and node-locked licenses”. For a more in-depth description of the two licensing models and a guide on how to implement them in practice, please read our documentation.

Are you new to Cryptolens? Welcome! We make it effortless for software creators to license and sell any type of application, in any programming language. Our software licensing system integrates with leading providers such as PayPal and Stripe to make payments secure.

Join hundreds of innovative and world-leading software companies – get started with Cryptolens today!


Get Started with Cryptolens Today!

Different types of software licenses - Cryptolens

What are different types of software licenses?

Choosing between the different software license types is a crucial decision when you are planning on licensing and selling your software product. That is why we are answering the question “What are different types of software licenses? to help you get started.

We will now briefly introduce some of the most common software licensing models that we offer to our customers. If you want to read more in detail, please visit our documentation pages.

This blog is also available as a YouTube video:

Types of software licenses

One of the most common types is called a perpetual license. That is when you charge a customer once, and they get full access to your product forever. A subscription is when you are continuously charging a customer. They are only granted access to your application if they continue to pay. The most common subscriptions are paid on a monthly, quarterly, or yearly basis.

It might also be beneficial to charge the customer only when they use the software or its features. For example, if you sell an accounting software product, you could charge your customers for each financial report they create using the software. This licensing model is called usage-based licensing.

Lastly, some companies want to allow only a limited number of machines to use their software at the same time. This can be done using node-locking or floating licenses, both of which we have covered in more detail in our documentation. You can then charge the customer extra for a license where they can to use your software on more machines at the same time.

We hope that gave you an answer to the question “What are different types of software licenses?” If you would like to read more about the licensing types, please read our documentation.

And if you are new to Cryptolens, welcome to our website! We offer a software licensing system for software developers to license and sell any type of software application. Our documentation pages give you detailed guides in your programming language on how to implement our licensing as a service (LaaS) platform.


Get Started with Cryptolens Today!

Different types of software licenses - Cryptolens

Floating licenses in an offline setting

In this blog, we will feature how floating licenses work in theory, including in offline settings. For the actual code examples, please read the following documentation page on floating licenses, including our License Server repository on GitHub. Scroll down to the section called “Floating licenses offline” to find the most relevant information.

Alternatively, you can watch the full tutorial including more information about how everything works in theory on YouTube:

Floating licenses in theory

Say that you want to restrict licenses to a set number of machines. This can either be done with floating licenses or node-locking. Node-locking works in such a way that you restrict licenses to a number of machines, and if you want to activate a new machine to that license, you have to manually deactivate one of the existing machines.

For floating licenses, you instead have a requirement that only a certain number of machines can use the license simultaneously, which eliminates the need to activate and deactivate machines.

This is perfect if, for example, a customer downloads your application on 100 machines. You can then limit the number of machines so that only 10 developers can use your application at the same time. If the customer is anticipated to change machines very frequently, you no longer have the hassle of activating or deactivating machines every time a developer changes machines.

But how does this work? Your application continuously sends heartbeats to our API as it’s running, which tells Cryptolens that that particular machine is active. If Cryptolens does not receive a heartbeat from that machine anymore, it will automatically be deactivated. Naturally, a new machine can be activated again, as long as no more than a set number of machines are being used at the same time. This allows you to potentially charge the customer more for a license that allows for more machines to simultaneously be able to access your application.

The offline approach

With the offline approach, you can even use floating licenses when your application runs in a locked-in environment without access to the internet, such as a docker container. Instead of having to send requests to Cryptolens, you can have your application send the requests to a local license server. In this way, your application can run in, for example, a docker container without encountering any licensing issues.

We have now covered the basics of how floating licenses work online and offline. If you want to set up floating licenses, please read the documentation, or watch the YouTube video provided earlier in this blog.

Please let us know if you have any questions. Thank you for reading!


Not a customer yet? Sign Up for a free trial and implement our software licensing system within minutes.

Automatically issue trial licenses

This blog post will focus on the Verified Trial feature in Cryptolens, allowing you to automatically generate trial license keys. The full documentation page can be found here.

You can also watch this tutorial as a YouTube video:

Let’s first cover the theory behind the Verified Trial feature. In your application, you would call a specific API method, in this case the Key.CreateTrialKey method, and supply the machine code or any other device identifier. As long as that machine code has not received a trial key before, a new trial key will automatically be generated and sent to the application.

Setting up the Verified Trial feature

To implement the Verified Trial feature, you would need to add additional code to your product. Please find this code example at the bottom of this blog post, or on the dedicated documentation page.

To set this up, we will begin with a limited version of the code so you can make sure that you get everything properly set up before you implement the feature. To get started, simply copy the code below and paste it into your application.

var newTrialKey = Key.CreateTrialKey("access token", new CreateTrialKeyModel {ProductId= "product id", MachineCode = "machine code" });

if(!Helpers.IsSuccessful(res))
{
	Console.WriteLine(res?.Message);
}

Console.WriteLine(res.Key);

For this to work, you need to enter an access token, your product ID, and the machine code into the code above.

Access Token
For the access token, you need to sign in to Cryptolens. Go to the Access Token page and click “Create new Access Token”.

Give your new access token a name. Under the “License Key” headline, click on the checkbox called “Create Trial Key”. To complete, click on “Create an Access Token”

At the top of the Access Token page, a green field will appear with the token you have just created. Copy the access token, either manually or by clicking on the blue icon to the right of the access token.

Paste the access token in your application’s code where it says “access token”.

Product ID:
Make sure you provide the correct Product ID of your desired Cryptolens product in your application’s code. You find the Product ID by going to the product’s page in Cryptolens. The Product ID should be visible just above the “Create a new key” button.

In the code you just pasted into your application, please provide the correct Product ID where it now says “product id”.

Machine Code:
Normally, you would use Helpers.GetMachineCode to get the correct machine code. For this example, however, you may specify your own machine code to make sure everything is working, and when you want the Verified Trial feature to go live, you should simply replace your example machine code with Helpers.GetMachineCode.

For this example, we will set the machine code to “test3” by entering it into the code where it says “machine code”.

Final Step:
Run the application. If everything works as it should, the newly created trial license key should appear. When the feature is live, you should proceed as normal with key verification after this step.

You can now find the trial key on the Product Page, just like it does when you create the key manually.

We will now cover a way of customizing the pre-defined features and the expiration date. If you do not wish to make any changes, proceed with the section of this blog called “Full implementation”.

Customizing the pre-defined features

Notice how the new key has the “trial” feature set as true. Unless you have specified that all licenses are time-limited, the trial key should also have another feature set as true, which is the “time-limited” feature.

If you want to change which feature is the trial and time-limited feature, click on Edit Feature Names. 

In Feature Definitions, you can specify which features you want to be the trial and time-limited feature. If you want all licenses to be treated as time-limited, you can click on the checkbox below the list of 8 features called “Treat all licenses as time-limited”.

Customizing the expiry date

Notice how the trial key you created will expire in 15 days. You can customize this by changing the access token.

Go to the Access Token page and delete the access token you created earlier in this tutorial by clicking on the cross icon to the right for the correct access token.

Click on Create new Access Token. Give the access token a name. Once again, select the “Create Trial Key” checkbox in the License Key section.

Scroll all the way down to the bottom of the page to find the Feature Lock field. In this field, you can specify the expiry date of the automatically issued trial license keys. If you want the trial license key to be valid for 30 days, simply write 30 in the Feature Lock field.

When you have specified your desired expiration date, click on Create an Access Token.

Copy the new access token by finding the green field at the top of the Access Token page as you did earlier and replace the old access token in your application’s code with the new one.

Remember to change the example machine code you provided earlier to see if everything is working. For this example, we will change the machine code to “test5”.

Run the application again. If everything works, the new trial license should appear.

Go back to the Product page and you should find the newly created trial license key with the expiry date that you specified in the access token’s Feature Lock field. For this example, the new key should be valid for 30 days.

Full implementation

To fully implement this feature, please see the code example below.

Notice that the first part is exactly the same as we pasted earlier, meaning that if you have followed the steps in this blog, that part is correctly customized for your application.

Lastly, remember to remove your example machine code and instead use Helpers.GetMachineCode, or any other method of identifying devices, as soon as you are done experimenting with the Verified Trial feature.

Here is the code example for full implementation:

var newTrialKey = Key.CreateTrialKey("access token", new CreateTrialKeyModel {ProductId= "product id", MachineCode =Helpers.GetMachineCode() });

if(newTrialKey == null || newTrialKey.Result == ResultType.Error)
{
    Assert.Fail("Something went wrong when creating the trial key");
}

var activate = Key.Activate("access token", 
    new ActivateModel {
        ProductId = 3941,
        Sign = true,
        MachineCode = Helpers.GetMachineCode(),
        Key = newTrialKey.Key, Metadata = true
    });

if(activate == null || activate.Result == ResultType.Error)
{
    Assert.Fail("Something went wrong when verifying the trial key");
}

// now we can verify some basic properties
if (Helpers.IsOnRightMachine(activate.LicenseKey) && activate.Metadata.LicenseStatus.IsValid)
{
    // license verification successful.
    return;
}

Assert.Fail();

Thank you for reading this blog, please reach out if you have any questions to [email protected].


Not a customer yet? Sign Up for a free trial and implement our software licensing system within minutes.

Blocking expired licenses automatically

In this blog guide, we will cover how to automatically block expired licenses in Cryptolens. This guide is based on a page from our documentation, which you can find here.

If you would rather watch a video of this guide, please watch the following:

The first step is to sign in to Cryptolens and go to the Product Page. Click on Edit Feature Names.

To implement automatic blocking of expired licenses, Cryptolens must know which licenses are time-limited, and there are two methods of doing that:

  1. You can designate a specific feature to be time-limited. To implement this method, simply choose what feature you want to be the time-limited feature, and enable it for the licenses you want to automatically block after they expire.
  1. You can also treat all licenses as time-limited, meaning that any license regardless of its features will automatically be blocked after it expires. To implement this, simply click on the checkbox below the feature list called “Treat all licenses as time-limited”.

Regardless of what method you choose, you must click on the checkbox below the feature list called “Block expired licenses”. Press Save.

There is also a way to automatically send email notifications to customers when their license is about to expire. You can find that tutorial here.

Thank you for reading this guide, please reach out to [email protected] if you have any questions.


Not a customer yet? Sign Up for a free trial and implement our software licensing system within minutes.

Speeding up license creation using License Templates

This blog features a convenient way of issuing multiple licenses with the same expiry date and enabled features, which can speed up the license creation process and make your work easier.

If you would rather watch a YouTube video of this guide, please watch the following video:

The feature covered in this blog is called License Templates, and you can read the full documentation here.

Start by signing in to Cryptolens, and go to the product you want to create a license template for. Click on “Create a new key” like you normally do to issue a license manually.

Select the features and the expiry date that you want. Instead of clicking on Create, you should click on Save as Template.

Give the license template a name. Notice that the “Parameters” field is already filled out. If you want to customize the parameters of your license template, please read the existing documentation.

When you are done customizing your template, click on Create.

Go back to the product and click on “Create a new key”. You should now be able to see the license template you created in the field called “License Templates”.

To make a new license with the same features and expiry date as you selected for the license template, simply select your newly created license template in that field, and click on the Create button to the right of the drop-down menu.

This method is useful if you, for example, want to issue multiple yearly or monthly licenses with the same features. It is also possible to retrieve the license templates through the API if you prefer to use the API for license creation.

Thank you for reading this blog, please reach out to us if you have any questions!


Not a customer yet? Sign Up for a free trial and implement our software licensing system within minutes.

Automatically notify customers at license expiration

In this blog, we will cover how you can automatically send emails to customers when a license is about to expire. You will be able to select time intervals for the emails and choose to send a copy to your own email as well.

We have also uploaded this guide as a video if you find that more convenient:

This guide is based on a page in our documentation that you can find here.

Setting up automatic expiration emails

Sign in to Cryptolens and head to the Product Page. For an existing product, click on “Edit Features” and scroll down. Click on the checkbox called “Automatic expiration notification” and then click on Save.

The feature is now enabled, but you need to tell Cryptolens which licenses are time-limited. This can be done in two ways:

  1. You can designate a particular feature to be the time-limited feature, meaning that any license with that particular feature set as true will be treated as time-limited.
  2. You can treat all licenses for your selected product as time-limited.

1: To designate a particular feature to be time-limited, simply select the “Time Limited” option in the drop-down menu for a particular feature’s “Type”, which can be found at the top of the Edit Feature Names page. Enable the chosen feature for the licenses you want to send email notifications to. Click on Save.

2: Click on the checkbox below the list of features near the top of the Edit Features Names page called “Treat all licenses as time-limited”. Click on Save.

Now that Cryptolens knows which licenses are time-limited, your customers will receive 3 email notifications, one 7 days in advance, one 3 days in advance, and one on the day that the license expires.

Customizing the time intervals

It is possible to customize the number of emails and the time intervals when they are being sent. To do this, head to the Product Page once again, and click on Data Objects.

cryptolens_expirationnotice

Copy the object name above and paste it into the field called “Name”.

By default, the string value is 0,3,7, meaning that an email will be sent 0 days prior, 3 days prior, and 7 days prior to the license expiration date. Simply change this string value to whatever time intervals you want. If you want to send more emails, just add a comma (,) and specify how many days prior to license expiration you want to send an email. For example, to send an extra email 10 days in advance, simply modify the string to be 0,3,7,10. Press on Create when you have chosen your preferred time intervals.

Sending a copy to your own email address

Stay on the Data Objects page if you want to set it up so that you receive a copy of the email that is being sent to customers.

cryptolens_expirationnotice_send_copy

Copy the data name above and paste it into the Name field. In the String Value field, you should provide the email to which you want the copy to be sent. Press on Create.


If you have any questions, please contact us at [email protected].


Not a customer yet? Sign Up for a free trial and implement our software licensing system within minutes.

Defining more than 8 features

In this blog, we will discuss how you can add more features in addition to the 8 features that come out of the box when using Cryptolens and our software licensing system. You will also learn how to create feature hierarchies.

This guide is also available as a video tutorial in case you prefer to take in information that way:

The first step is to sign in to Cryptolens and bring up the Product Page. Once you have created a product and a license key, you may already be aware that you can click on the license key to enable or disable up to 8 features.

Let’s suppose that you’d like to add feature 9, or even define a feature hierarchy where you create a module with multiple sub-modules. This can easily be done using Feature Templates, which are described in more detail in our documentation.

Multiple Features Without Hierarchy

The example listed below allows you to add additional features without defining any feature hierarchy.

["ModuleA", "ModuleB", "ModuleC"]

You may change the name and the number of new features in the code to suit your needs. If you do not wish to make any changes, simply copy the code above and head back to the Product Page on the Cryptolens dashboard. Click on “Edit Feature Names”.

Scroll down to find the Feature Template field, and paste the copied or modified code into that field. Press the Save button and go back to the Product Page. When you press a license key, the new features will now appear below the original 8 features. The end result is shown below.

Multiple Features With Hierarchy

Let’s now suppose that you would like to add a sub-module to a particular feature. In this example, you will learn how to create two sub-modules for Module B, but the same logic can be applied to define whatever hierarchy suits your needs the best.

This section begins after the above-mentioned one ends, so if you have not already, please begin with the steps mentioned above regarding “Multiple Features Without Hierarchy”.

Head back to your Product Page on the Cryptolens Dashboard and press “Edit Feature Names”. Scroll down to the Feature Template field to find the code you pasted earlier. To define feature hierarchies, you will have to modify this code slightly.

The following code shows how to create two sub-modules for Module B. Simply replace “ModuleB” from the code in the Feature Template field with the following code:

["Module B", ["Submodule 1", "Submodule 2"]]

As you can see, the first element in the list is the name of the main feature, and the following elements will be the associated sub-modules. Using the same logic, you can define whatever feature hierarchy suits your needs. Keep in mind that you also can define sub-sub-modules.

The following code shows the end result if you just want to make three new features, whereas Module B has two sub-modules:

["ModuleA", ["Module B", ["Submodule 1", "Submodule 2"]] , "ModuleC"]

When you have created your desired hierarchy, hit Save, go back to the Product Page, and click on the license key. You will now see additional features listed below the original 8, with the hierarchy you have defined.

Below you will find what the hierarchy looks like from our example.

If you have any questions, please reach out to us at [email protected].


Not a customer yet? Sign Up for a free trial and implement our software licensing system within minutes.

Bundling software licenses best practises

As you grow your product offering, a challenge that can arise is how to differentiate between different products, and, at the same time, offer a seamless experience to your customers. We will present two approaches that can be used in Cryptolens and outline best practises when implementing license key verification in a product with multiple modules.

Using one license for multiple products

With this approach, the information about your products/modules is stored within one license key. In other words, you would just need to create one product in the Cryptolens dashboard. To differentiate between your products, you could either use the pre-defined features (F1 to F8) or define a more detailed feature hierarchy using feature templates.

This approach tends to work in most cases. However, in some cases it is still more desirable to be able to issue separate license keys for each product or module. We will describe this approach in the next section.

Separate license key per product bundled in a master license

If the previous approach is not an option, another way is to create one Cryptolens product per product/module. Typically the reason why this approach is more desirable is that it allows you to have separate trials or subscriptions attached to each license. For example, let’s suppose you have a product that offers additional features that are not part of the main product. By using a separate license key for the additional features or sub-products, you could allow your clients to test them out independently.

However, this approach would mean that your customers will need to keep track of multiple licenses at once. To solve this, we recently released an update to the API and the customer object. From now on, assuming that licenses are linked to the same customer, they can be retrieved using one API call using the customer secret.

Best practises when a product consists of independent modules

When a product is split up into independent modules, calling Key.Activate (a method used to verify a license with the server) each time a module starts is not optimal in most cases. Instead, a better approach is to verify the license with the server once at startup and then save the License Key object to file. Before another module is launched, it can check for existence of such file (and ensure that it is not too old) and then use it instead of calling the server. When it comes to obfuscation, it is more important to focus on obfuscating the method that loads the License Key object then the code that obtains the License Key object from the server.

If you have any questions, please feel free to reach out to us at [email protected].


Not a customer yet? Sign Up for a free trial and implement our software licensing system within minutes.