License Feature Check

Use this endpoint to check a license device against a license feature. Once checked, the device will be connected to the feature. If the feature is floating, the device will also take one floating slot if available.

Endpoint

• Method: GET
• Path: /api/v4/check_license_feature
• Description: Checks a license device against a license feature.

Authentication

See License API Authorization.

Required headers

• Date (string) — RFC7231 GMT date string
• Authorization (string)

Optional headers

• licensespring-tpm-signature (string) — TPM licensing signature and algorithm

  • licensespring-tpm-signature: algorithm="ES256",signature=""

Recommended headers

• Accept: application/json

Request

Query parameters (TypeScript)

type LicenseFeatureCheckRequestParams = ({

  // for key-based licenses:
  license_key: string

} | {

  // for user-based licenses:
  username: string

}) & {

  // required properties:
  hardware_id: string
  product: string
  feature: string

  // optional properties:
  license_id?: number | undefined
}

JSON Schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "allOf": [
    {
      "oneOf": [
        {
          "type": "object",
          "properties": {
            "license_key": { "type": "string" }
          },
          "required": ["license_key"],
          "additionalProperties": false
        },
        {
          "type": "object",
          "properties": {
            "username": { "type": "string" }
          },
          "required": ["username"],
          "additionalProperties": false
        }
      ]
    },
    {
      "type": "object",
      "properties": {
        "hardware_id": { "type": "string" },
        "product": { "type": "string" },
        "feature": { "type": "string" },
        "license_id": { "type": ["number", "null"] }
      },
      "required": ["hardware_id", "product", "feature"],
      "additionalProperties": false
    }
  ]
}

Query parameters summary

Required:

• hardware_id (string) — Unique hardware ID generated for the client device
• product (string) — Product short code
• feature (string) — Feature code

One of:

• license_key (string) — Required if product is key-based
• username (string) — Required if product is user-based

Optional:

• license_id (number) — Targets a specific license ID

Examples

curl

curl --location --request GET '/api/v4/check_license_feature?hardware_id=string&product=string&feature=string&license_key=string' \
--header 'Accept: application/json' \
--header 'Date: string' \
--header 'Authorization: string'

nodejs

var request = require('request');
var options = {
  method: 'GET',
  url: '/api/v4/check_license_feature?hardware_id=string&product=string&feature=string&license_key=string',
  headers: {
    'Accept': 'application/json',
    'Date': 'string',
    'Authorization': 'string'
  }
};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});

javascript (fetch)

var myHeaders = new Headers();
myHeaders.append("Accept", "application/json");
myHeaders.append("Date", "string");
myHeaders.append("Authorization", "string");

var requestOptions = {
  method: 'GET',
  headers: myHeaders,
  redirect: 'follow'
};

fetch("/api/v4/check_license_feature?hardware_id=string&product=string&feature=string&license_key=string", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));

python

import requests

url = "/api/v4/check_license_feature?hardware_id=string&product=string&feature=string&license_key=string"

headers = {
  "Accept": "application/json",
  "Date": "string",
  "Authorization": "string"
}

response = requests.get(url, headers=headers)
print(response.text)

ruby

require "uri"
require "net/http"

url = URI("/api/v4/check_license_feature?hardware_id=string&product=string&feature=string&license_key=string")

http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Get.new(url)
request["Accept"] = "application/json"
request["Date"] = "string"
request["Authorization"] = "string"

response = http.request(request)
puts response.read_body

Response

Response body (TypeScript)

type LicenseFeatureCheckResponseBody = {
    allow_negative_consumptions: boolean,
    allow_overages: boolean,
    allow_unlimited_consumptions: boolean,
    code: string,
    consumption_period: string,
    expiry_date: null | string,
    feature_type: string,
    id: number,
    is_floating_cloud: boolean,
    is_floating: boolean,
    license_id: number,
    max_consumption: number,
    max_overages: number,
    metadata: JSON,
    name: string,
    reset_consumption: boolean,
    total_consumptions: number,
    
    // the following property is only present on floating and floating cloud features:
    floating_in_use_devices?: number,
}

JSON Schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "allow_negative_consumptions": { "type": "boolean" },
    "allow_overages": { "type": "boolean" },
    "allow_unlimited_consumptions": { "type": "boolean" },
    "code": { "type": "string" },
    "consumption_period": { "type": "string" },
    "expiry_date": { "type": ["string", "null"] },
    "feature_type": { "type": "string" },
    "id": { "type": "number" },
    "is_floating_cloud": { "type": "boolean" },
    "is_floating": { "type": "boolean" },
    "license_id": { "type": "number" },
    "max_consumption": { "type": "number" },
    "max_overages": { "type": "number" },
    "metadata": { "type": "object" },
    "name": { "type": "string" },
    "reset_consumption": { "type": "boolean" },
    "total_consumptions": { "type": "number" },
    "floating_in_use_devices": { "type": "number" }
  },
  "required": [
    "allow_negative_consumptions",
    "allow_overages",
    "allow_unlimited_consumptions",
    "code",
    "consumption_period",
    "expiry_date",
    "feature_type",
    "id",
    "is_floating_cloud",
    "is_floating",
    "license_id",
    "max_consumption",
    "max_overages",
    "metadata",
    "name",
    "reset_consumption",
    "total_consumptions"
  ],
  "additionalProperties": false
}

Notes:

• floating_in_use_devices — number of devices currently in use on this license feature (present only on floating and floating cloud features)
• license_id — id of the license

Errors

If an error occurs, the response will have an HTTP status code of 400 or higher. The response body will contain an error description in the following format:

{
  status: number,
  code: string,
  message: string
}

JSON Schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "status": { "type": "number" },
    "code": { "type": "string" },
    "message": { "type": "string" }
  },
  "required": [
    "status",
    "code",
    "message"
  ],
  "additionalProperties": false
}

List of exceptions

• missing_headers (400): Some headers are missing
• unknown_product (400): Provided product was not found
• license_not_found (400): License with the provided license user not found
• license_not_enabled (400): The license is not enabled
• license_not_active (400): The license is not active
• device_not_found (400): An active device matching the hardware_id not found
• blacklisted (400): This device is blacklisted
• invalid_license_feature_code (400): License feature code: ' + param + ' is invalid or not assigned to the license.
• floating_not_available (400): No available slots for floating license.
• tpm_invalid_public_key (400): The TPM public key sent is not valid
• tpm_signature_required (400): The TPM signature is missing from the header and TPM usage is enforced
• tpm_signature_missmatch (400): The TPM signature/algorithm is not ES256 and the signature can't be verified against the TPM public key