Author: Artem Los

How do you implement a Software Licensing System?

When you are thinking about licensing and selling your software product, you probably come across the question “How do you implement a software licensing system?” In this blog, we will cover the basics of Cryptolens so you can get an idea of how you can implement a software licensing system and start to license and sell your software product.

Please visit our help pages if you want to learn more. You can also learn about software licensing basics in the following video:

Implement a software licensing system

There are three easy steps to get started in Cryptolens.

  1. Install our SDK in your programming language
  2. Create a free Cryptolens account
  3. Insert a code snippet into your code

Let us begin with the SDK. Cryptolens offers comprehensive SDKs in your favorite programming languages to make it effortless to implement a software licensing manager within minutes. Install our SDK in your language here.

Create a free Cryptolens account to get access to our easy-to-use dashboard where you can create and manage license keys and restrictions. You can also find your access tokens and other parameters that you have to insert into your code. Cryptolens offers you a way to implement licensing for free at your own pace, and you only have to pay when you get customers of your own.

The last step is to insert a code snippet into your application’s code. We provide comprehensive help guides to make the implementation seem effortless. The following image gives a summary of how our code snippet looks. See the code snippet in your programming language here.

License key verification is effortless with Cryptolens in any coding language!

Are you new to Cryptolens? Welcome! We are dedicated to offering an easy-to-use Licensing as a Service (LaaS) platform so you can license and sell your software application within minutes.


Get Started with Cryptolens Today!

Offline license verifications

Welcome to our blog featuring offline license verifications in Cryptolens. We will cover how to set up offline verification in theory and in practice, regarding two major use cases:

  1. When a customer is allowed to temporarily be offline (for example, use the license while they are in airplane mode).
  2. When a customer is allowed to permanently be offline (for example, behind a corporate firewall).

This blog is based on the following page in our documentation.

Here is a YouTube video covering the same topic:

Background

Let us refresh our memory of the standard license key verification code. For the remainder of this blog, we will cover example codes in Python, but the process is similar in other languages.

Below you can find the basic key verification code in Python.

result = Key.activate(token=auth,\
  rsa_pub_key=RSAPubKey,\
  product_id=3349, \
  key="ICVLD-VVSZR-ZTICT-YKGXL",\
  machine_code=Helpers.GetMachineCode(v=2))

if result[0] == None or not Helpers.IsOnRightMachine(result[0], v=2):
  # an error occurred or the key is invalid or it cannot be activated
  # (eg. the limit of activated devices was achieved)
  print("The license does not work: {0}".format(result[1]))
else:
  # everything went fine if we are here!
  print("The license is valid!")

When Key.Activate is called, it calls Cryptolens API, which in turn returns a signed JSON object placed in the result variable. This allows you to proceed as normal and check features, expiry dates, and other parameters. In the code above, we are checking if the license is activated on the correct machine.

Using the following code in Python, we can save the JSON object to disk, allowing us to read it again when the customer lacks internet access.

# res is obtained from the code above
if result[0] != None:
  # saving license file to disk
  with open('licensefile.skm', 'w') as f:
    f.write(result[0].save_as_string())

Case 1 – Temporarily offline

If customers are expected to be offline once in a while, it is considered good practice to always attempt to make the key.activate call, and only load the saved license file from disk if the customer is offline and key.activate fails.

The following Python code example shows you how to load the saved license file from disk:

# read license file from file
with open('licensefile.skm', 'r') as f:
  license_key = LicenseKey.load_from_string(pubKey, f.read(), 30)

if license_key == None or not Helpers.IsOnRightMachine(license_key, v=2):
  print("NOTE: This license file does not belong to this machine.")
else:
  print("Feature 1: " + str(license_key.f1))
  print("License expires: " + str(license_key.expires))

Notice that the parameter load_from_string has “30” set as a parameter. This means that the customer is only allowed to use the software offline for 30 days. You can customize this value so it suits your use case. For example, you may want to change it to 7, if you only want to allow a customer to be offline for a week.

When the date has been reached, the customer will need a new license file (which may be obtained by successfully calling key.activate), which can be done with the LoadFromFile method.

You could also remove the “30” parameter if you do not want to set a limit at all.

If you want to see more code examples in Python, please visit our GitHub page.

Case 2 – Permanently offline

To support customers to be fully offline and still use your software for a long period of time, you would have to send the license file to your customers since they cannot call key.activate.

There are four methods you can use:

  1. Calling key.activate on your end and sending the file to your customer. You can automate this method.
  2. Using Activation forms hosted by Cryptolens for an easier solution.
  3. Obtaining the file manually in the dashboard.
  4. An On-premise License Server by Cryptolens for when you anticipate many end users or want to support floating licenses offline.

1:

The first method is where you call key.activate on your end and send the license file to your customer, for example, over an email. If you would like, you could set up an automized way where your customers can request to download their license file from your dashboard. This could, however, become somewhat complex.

2:

An easier way is to use activation forms by Cryptolens. When inside the Cryptolens dashboard, open the tab called “Forms”, and click on Activation Forms. This form performs a call to key.activate much like you would do on your own in the previous method, but we provide a simpler GUI for your and your customer’s convenience.

Using the form, customers can simply enter their license key and machine code, click on active, and they will obtain their license file that they can insert on their machines.

3:

You can also manually download the license file from the Cryptolens dashboard. Go to the desired product page, find the license key you want to download the license file of, and click on the yellow wrench icon to the right of the key. Click on “Download activation file” and send it in your desired way to your customer.

4:

All of the above-mentioned methods are useful when there are only a few employees on site who would use your software offline. But, if you anticipate that your customers will have many end users, or if you want to support floating licenses offline, you can use an on-premise license server that Cryptolens provides. Please read the documentation relating to the on-premise license server to learn more about this approach.

Thank you for reading this blog about setting up offline license verifications in Cryptolens, please feel free to ask questions to [email protected].


Get Started with Cryptolens Today!

How does software licensing work?

A common question when selling and licensing a software application is “How does software licensing work?”. Understanding the basics of software licensing allows you to make smarter decisions when it comes to monetizing your software.

It is crucial that your software is able to know who is allowed access and for how long. Depending on what licensing model you choose, the software licensing system will behave differently. We are briefly explaining how software licensing works in this blog.

You can also watch the associated YouTube video:

Explaining how software licensing works

A licensing as a service (LaaS) provider such as Cryptolens will do most of the heavy lifting. When a user of your software signs up, your software sends a request to a license server. The license server then checks if all of the requirements are met. For example, was the customer’s last payment successful?

If all of the requirements are satisfied, the license server sends a response back to your software that tells it to run as normal. If, for example, the customer did not pay their last payment, the license server will tell your software to display a message telling the customer what they need to do to gain access to the software again.

In some instances, your software may be unable to send a request to the license server. For example, your software might be running without Internet access. Your software would then use a license file on disk or call an on-premise license server. At Cryptolens, we provide methods of doing both of the options to our customers.

We have now answered the question “How does software licensing work?”. If you are new to Cryptolens, welcome to our site! We enable our customers to license and sell any type of software application. With help guides in your favorite programming language, you can implement software licensing within minutes. Hundreds of industry-leading customers worldwide are already using our software licensing manager.


Get Started with Cryptolens Today!

Different types of software licenses - Cryptolens

Start countdown upon activation

Welcome! This blog is covering our feature called “Start countdown upon activation in Cryptolens”, 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 and activates the license on another machine 7 days later, the license will be valid for another 30 days. This means it will be valid for 37 days in total.

If you allow for more than two machines, this phenomenon can then naturally happen more than once. The license might then 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.

Now you know how to start the countdown upon activation in Cryptolens. 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 explain the theory behind floating licenses in an offline setting in Cryptolens. For the actual code examples, please read the following documentation page on floating licenses. You can also check out 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. This 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 floating licenses in an offline setting in Cryptolens. 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 issue trial licenses in Cryptolens. 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 trial licenses in Cryptolens

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.

You have almost learned how to automatically issue trial licenses in Cryptolens. 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();

Now you know how to automatically issue trial licenses in Cryptolens.

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 a method of blocking expired licenses automatically 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.

Now you know more about blocking expired licenses automatically in Cryptolens. But what about deleting license keys completely? You cannot remove expired licenses due to security reasons. It is however important to block licenses that are not used. This is because Cryptolens charges a small fee for each active license.

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 speeding up license creation using license templates in Cryptolens. Issuing multiple licenses with the same expiry date and enabled features 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.

License Templates tutorial

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.

Know you now more about speeding up license creation using license templates in Cryptolens. 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.