Deactivate Bundle (Offline Method)

Deactivate Bundle (Offline Method)

Deactivates a bundle using the offline activation method. Returns the list of affected licenses in response.

---

Endpoint

• Method: POST

• Path: /api/v4/deactivate_bundle_offline

• Description: Deactivates a bundle using the offline flow (base64 payload).

Authentication

See License API Authorization.

Required headers

• Date (string) — RFC7231 GMT date string

• Authorization (string) — signature or bearer token

Recommended headers

• Accept: application/json

Request

Body

The request body is a base64-encoded, stringified JSON object (see schema below).

If using multipart/form-data, the file form parameter is mandatory.

Examples

curl

curl --location --request POST '/api/v4/deactivate_bundle_offline' \
--header 'Accept: application/json' \
--header 'Date: string' \
--header 'Authorization: string' \
--data-raw '_BASE64_PAYLOAD_HERE_'

nodejs

javascript (browser / fetch)

python

ruby

---

Schema

Request Body

The request body is a string representing a base64-encoded JSON object containing all the required activation data.

If using "multipart/form-data" for the request, the "file" form parameter is mandatory

Request schema (TypeScript + JSON Schema)

TypeScript

type LicenseOfflineActivationObject = ({

  // for key-based licenses:
  license_key: string

} | {

  // for user-based licenses:
  username: string

}) & {

  // required properties:
  hardware_id: string
  product: string
  request_id: string
  signature: string
  date: string
  request: "deactivation"

} & ({
  api_key: string // for API key authorization
} | {
  client_id: string // for OAuth authorization
}) & {

  // optional properties:
  license_id?: number | undefined
  sdk_ver?: string | 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": {
        "api_key": { "type": "string" },
        "client_id": { "type": "string" },
        "request": { "type": "string" },
        "request_id": { "type": "string" },
        "date": { "type": "string" },
        "signature": { "type": "string" },
        "hardware_id": { "type": "string" },
        "product": { "type": "string" },
        "license_id": { "type": "number" },
        "sdk_ver": { "type": "string" }
      },
     "allOf": [
        { "anyOf": [{ "required": ["api_key"] }, { "required": ["client_id"] }] },
        { "anyOf": [{ "required": ["license_key"] }, { "required": ["username"] }] }
      ],
      "required": ["hardware_id", "product", "date", "signature"],
      "additionalProperties": false
    }
  ]
}

---

Signature

The signature value is constructed by creating a signing string and HMAC-SHA256 signing it with the company shared key (or client secret for OAuth). Build the signing string from these parts in order and with newline separators:

1

Step

Start with the string: licenseSpring

2

Step

Add a newline and the string: date:

3

Step

Add a newline and either the license_key or username value (whichever is present)

4

Step

Add a newline and the hardware_id value

5

Step

Add a newline and the api_key (or client_id) value

Then HMAC-SHA256 the complete signing string using the signing key:

• If using API key authorization: signing key = Shared Key

• If using OAuth: signing key = Client Secret

Example (Node.js):

import crypto from 'node:crypto';

const activationPayload = {
  // ...payload content...
};

// api_key or client_id depending on authorization type used:
const key = (activationPayload.api_key || activationPayload.client_id);

// if using API key authorization: the signing key is the Shared Key
// if using OAuth: the signing key is the Client Secret
const signingKey = '...';

const signingString =
  'licenseSpring\n' +
  'date: ' + activationPayload.date + '\n' +
  (activationPayload.license_key || activationPayload.username) + '\n' +
  activationPayload.hardware_id + '\n' +
  key;

const signature = crypto
  .createHmac('sha256', signingKey)
  .update(signingString)
  .digest('base64');

---

Finalized payload

Stringify the payload object and encode to base64.

JS Browser

const activationPayload = {
  // ...payload content...
};
const requestBody = btoa(JSON.stringify(activationPayload));

nodeJS

Send the resulting base64 string as the raw request body.

---

Response Body

Success:

• HTTP 200

• Body: "license_deactivated"

Errors:

• HTTP 400 or higher

• Body format:

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

JSON Schema for error responses:

{
  "$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

  • when missing authorization or date headers

• missing_parameters (400): some parameters are missing in the request

  • when no request body at all or no file found in request body

• authorization_missing_params (400): some parameters are missing in authorization

  • when request body is not properly base64 encoded

  • when file is missing in request body

  • when license_key or hardware_id body parameters are missing

  • when data body parameter is missing

  • when api_key parameter is missing

• product_not_bundle (400): Specified product "{CODE}" is not a bundle

If you want to use this API endpoint directly, instead of using SDK (which does most of the heavy lifting), please contact us for additional instructions.

---

License Authorization Method

There are two authorization approaches for products:

• Key-based product licenses

  • Client provides license_key in the request body.

  • License response object will contain license_key.

  • product_details.authorization_method = license_key.

• User-based product licenses

  • Requires username (and password where applicable).

  • product_details.authorization_method = user.

  • Response includes a user object with license user info.

---

License Types

The license_type property can be:

• Perpetual: perpetual

• Time-limited: time-limited

• Subscription: subscription

• Consumption: consumption

For more information see: License Types

---

Device variables

The optional variables parameter lets you set device variables during activation. For more information see: Device Variables

---

Guide on using Offline Licenses

If any aspect of the offline licensing model remains unclear, see the in-depth guide: https://docs.licensespring.com/license-entitlements/activation-types/offline