Create Order

16min
POST
Request
Body Parameters
id
String
required
Order ID. This is a unique identifier for an order within a company
is_bundle
Boolean
optional
If true, defines the order as a bundle order. Defaults to false. For more details on bundle orders, see the Bundle section below
append
Boolean
optional
If set to true and order ID already exists, licenses (items) sent will be appended to the existing order.
If set to false and order ID already exists, an error will be returned.
If not set defaults to false.
is_test
Boolean
optional
Whether or not this is a test order
created
String
optional
Date and time order is created
order_type
String
optional
Current possible value is: normal
language
String
optional
Order language, value should be language short code
campaign_params
String
optional
e.g. Google campaign params for the order
download_id
String
optional
Custom order download ID
prevent_vm
String
optional
If set to true, license activation won't be possible on a Virtual Machine
metadata
String
optional
Custom metadata, in the format of a serialized JSON object
items
Object
required
Product licenses in this order
customer
Object
optional
Customer data for the order
customer_account_id
Number
optional
Assignes the order to a Customer Account. If the provided Customer is already assigned to a Customer Account, you can omit this value
add_to_customer_account
Boolean
optional
Determines whether the Order will be assigned to a Customer Account (defaults to `true`). If you're providing a Customer who is assigned to a Customer Account, but do not wish the Order to be automatically assigned to that same Customer Account, set this parameter to false
JSON
see below
see below
Responses
200
see below
see below
﻿
Metadata should be in literal string format, e.g: "metadata": "{ \"some_key\": \"some_value\" }"
Request
The id property in the request is a client-generated unique identifier for the request, such as a uuid string
Non-Bundle Order Request
TypeScript
JSON Schema
Example: Key-based license
Example: User-based license
type RequestSchema = {
  id: string;
  append?: boolean;
  campaign_params?: string;
  created?: string;
  download_id?: string;
  include_metadata_string?: boolean;
  is_test?: boolean;
  language?: string;
  prevent_vm?: boolean;
  add_to_customer_account?: boolean;
  customer?: Customer;
  items: Item[];
}

type Item = {
  active?: boolean;
  customer_account_id?: number;
  key?: string;
  license_policy?: string;
  note?: string;
  product_code: string;
  subscription_id?: string;
  licenses: License[];
}

type Customer = {
  email?: string;
  first_name?: string;
  last_name?: string;
  company_name?: string;
  phone?: string;
  reference?: string;
}

type License = (LicenseWithKey | LicenseWithUsers) & LicenseOptional;

type LicenseWithKey = {
  key?: string;
}

type LicenseWithUsers = {
  users: {
    email: string;
    is_manager?: boolean;
  }[];
}

type LicenseOptional = {
  active?: boolean,
  allow_grace_period?: boolean,
  allow_negative_consumptions?: boolean,
  allow_overages?: boolean,
  allow_unlimited_activations?: boolean,
  allow_unlimited_consumptions?: boolean,
  can_borrow?: boolean,
  consumption_period?: string,
  enable_maintenance_period?: boolean,
  enabled?: boolean,
  floating_timeout?: number,
  floating_users?: number,
  grace_period?: number,
  is_air_gapped?: boolean,
  is_floating_cloud?: boolean,
  is_floating?: boolean,
  is_hardware_key_auth?: boolean,
  is_trial?: boolean,
  license_template_code?: string,
  license_template?: number,
  license_type?: LicenseTypes,
  maintenance_duration?: string,
  maintenance_period?: string,
  max_activations?: number,
  max_borrow_time?: number,
  max_consumptions?: number,
  max_license_users?: number,
  max_overages?: number,
  max_transfers?: number,
  metadata?: JSONObjectRequired | null,
  policy_code?: string,
  prevent_vm?: boolean,
  reset_consumption?: boolean,
  start_date?: string,
  subscription_id?: string,
  trial_days?: number,
  valid_duration?: string,
  validity_period?: string,
  custom_fields?: CustomField[],
  product_features?: ProductFeature[],
}

type CustomField = {
  name: string,
  data_type: 'numer' | 'text' | 'date/time',
  value: string | undefined;
};

type ProductFeature = 'string' | {
  code: string,
  allow_overages?: boolean,
  allow_unlimited_consumptions?: boolean,
  allow_negative_consumptions?: boolean,
  consumption_period?: string,
  expiry_date?: string,
  floating_timeout?: number,
  floating_users?: number,
  is_floating_cloud?: boolean,
  is_floating?: boolean,
  max_consumption?: number,
  max_overages?: number,
  metadata?: JSONObjectRequired,
  reset_consumption?: boolean,
};
type RequestSchema = {
  id: string;
  append?: boolean;
  campaign_params?: string;
  created?: string;
  download_id?: string;
  include_metadata_string?: boolean;
  is_test?: boolean;
  language?: string;
  prevent_vm?: boolean;
  add_to_customer_account?: boolean;
  customer?: Customer;
  items: Item[];
}

type Item = {
  active?: boolean;
  customer_account_id?: number;
  key?: string;
  license_policy?: string;
  note?: string;
  product_code: string;
  subscription_id?: string;
  licenses: License[];
}

type Customer = {
  email?: string;
  first_name?: string;
  last_name?: string;
  company_name?: string;
  phone?: string;
  reference?: string;
}

type License = (LicenseWithKey | LicenseWithUsers) & LicenseOptional;

type LicenseWithKey = {
  key?: string;
}

type LicenseWithUsers = {
  users: {
    email: string;
    is_manager?: boolean;
  }[];
}

type LicenseOptional = {
  active?: boolean,
  allow_grace_period?: boolean,
  allow_negative_consumptions?: boolean,
  allow_overages?: boolean,
  allow_unlimited_activations?: boolean,
  allow_unlimited_consumptions?: boolean,
  can_borrow?: boolean,
  consumption_period?: string,
  enable_maintenance_period?: boolean,
  enabled?: boolean,
  floating_timeout?: number,
  floating_users?: number,
  grace_period?: number,
  is_air_gapped?: boolean,
  is_floating_cloud?: boolean,
  is_floating?: boolean,
  is_hardware_key_auth?: boolean,
  is_trial?: boolean,
  license_template_code?: string,
  license_template?: number,
  license_type?: LicenseTypes,
  maintenance_duration?: string,
  maintenance_period?: string,
  max_activations?: number,
  max_borrow_time?: number,
  max_consumptions?: number,
  max_license_users?: number,
  max_overages?: number,
  max_transfers?: number,
  metadata?: JSONObjectRequired | null,
  policy_code?: string,
  prevent_vm?: boolean,
  reset_consumption?: boolean,
  start_date?: string,
  subscription_id?: string,
  trial_days?: number,
  valid_duration?: string,
  validity_period?: string,
  custom_fields?: CustomField[],
  product_features?: ProductFeature[],
}

type CustomField = {
  name: string,
  data_type: 'numer' | 'text' | 'date/time',
  value: string | undefined;
};

type ProductFeature = 'string' | {
  code: string,
  allow_overages?: boolean,
  allow_unlimited_consumptions?: boolean,
  allow_negative_consumptions?: boolean,
  consumption_period?: string,
  expiry_date?: string,
  floating_timeout?: number,
  floating_users?: number,
  is_floating_cloud?: boolean,
  is_floating?: boolean,
  max_consumption?: number,
  max_overages?: number,
  metadata?: JSONObjectRequired,
  reset_consumption?: boolean,
};
﻿
Bundle Order Request
TypeScript
JSON Schema
Example: Key-based bundle
Example: User-based bundle
{
    "id": "45gvs334t3edsa",
    "is_bundle": true,
    "items": [
        {
          "product_code": "lkpb",
          "key": "AAAA-AAAA-AAAA-1130",
          "active": true,
          "subscription_id": 12345,
          "licenses": [
            {
                "product_code": "lkbp1"
            },
            {
                "product_code": "lkbp2"
            }
          ]
        }
      ]
}
{
    "id": "45gvs334t3edsa",
    "is_bundle": true,
    "items": [
        {
          "product_code": "lkpb",
          "key": "AAAA-AAAA-AAAA-1130",
          "active": true,
          "subscription_id": 12345,
          "licenses": [
            {
                "product_code": "lkbp1"
            },
            {
                "product_code": "lkbp2"
            }
          ]
        }
      ]
}
﻿
Response
Non-Bundle Order Response
TypeScript
JSON Schema
Example response
type OrderResponse = {
  order_id: string,
  order_items: [
    {
      id: number,
      product_id: number,
      Licenses: License[],
    }
  ],
  new_passwords: { email: string, password: string }[],
}

type License = LicenseCommon & ({
  license_key: string;
  users: never;
  max_license_users: never;
} | {
  license_key: never;
  users: {
    email: string,
    first_name?: string,
    last_name?: string,
    phone_number?: string,
    is_manager: boolean,
  }[];
  max_license_users: number;
}) & ({
  license_type: 'perpetual'
} | {
  license_type: 'subscription';
  allow_grace_period: boolean;
  grace_period: number;
  time_activated: number;
} | {
  license_type: 'consumption';
  allow_negative_consumptions: boolean;
  allow_overages: boolean;
  allow_unlimited_consumptions: boolean;
  consumption_period: string | null;
  max_consumptions: number;
  max_overages: number;
  reset_consumption: boolean;
} | {
  license_type: 'time-limited'
}) & ({
  enable_maintenance_period: false;
} | {
  enable_maintenance_period: true;
  maintenance_duration: string;
  maintenance_period?: string | null;
});

type LicenseCommon = {
  id: number,
  product_id: number,
  active: boolean,
  enabled: true,
  created_at: number,
  updated_at: number,
  license_type: LicenseTypes,
  max_activations: number,
  allow_unlimited_activations: boolean,
  valid_duration: string | null,
  floating_timeout: number,
  max_transfers: number,
  can_borrow: boolean,
  max_borrow_time: number,
  start_date: string | null,
  is_air_gapped: boolean,
  license_template_id: number | null,
  validity_period: string | null,
  subscription_id: string,
  enable_maintenance_period: boolean,
  is_floating_cloud: boolean,
  is_floating: boolean,
  floating_users: number,
  is_trial: boolean,
  trial_days: number,
  prevent_vm: boolean,
  metadata: Record<string, any>,
  is_hardware_key_auth: boolean,
  order_id: number,
  LicenseCustomFields: {
    product_custom_field_id: number;
    value: string | undefined;
  }[],
  LicenseProductFeatures: {
    id: number,
    allow_negative_consumptions: boolean,
    allow_overages: boolean,
    allow_unlimited_consumptions: boolean,
    consumption_period?: string,
    expiry_date: string | null,
    floating_timeout: number,
    floating_users?: number,
    is_floating_cloud?: boolean,
    is_floating?: boolean,
    max_consumption: number,
    max_overages: number,
    metadata: Record<string, any>,
    name?: string,
    product_feature_id: number,
    reset_consumption: boolean,
  }[],
};

enum LicenseTypes {
  perpetual = 'perpetual',
  time_limited = 'time-limited',
  consumption = 'consumption',
  subscription = 'subscription',
};

type OrderResponse = {
  order_id: string,
  order_items: [
    {
      id: number,
      product_id: number,
      Licenses: License[],
    }
  ],
  new_passwords: { email: string, password: string }[],
}

type License = LicenseCommon & ({
  license_key: string;
  users: never;
  max_license_users: never;
} | {
  license_key: never;
  users: {
    email: string,
    first_name?: string,
    last_name?: string,
    phone_number?: string,
    is_manager: boolean,
  }[];
  max_license_users: number;
}) & ({
  license_type: 'perpetual'
} | {
  license_type: 'subscription';
  allow_grace_period: boolean;
  grace_period: number;
  time_activated: number;
} | {
  license_type: 'consumption';
  allow_negative_consumptions: boolean;
  allow_overages: boolean;
  allow_unlimited_consumptions: boolean;
  consumption_period: string | null;
  max_consumptions: number;
  max_overages: number;
  reset_consumption: boolean;
} | {
  license_type: 'time-limited'
}) & ({
  enable_maintenance_period: false;
} | {
  enable_maintenance_period: true;
  maintenance_duration: string;
  maintenance_period?: string | null;
});

type LicenseCommon = {
  id: number,
  product_id: number,
  active: boolean,
  enabled: true,
  created_at: number,
  updated_at: number,
  license_type: LicenseTypes,
  max_activations: number,
  allow_unlimited_activations: boolean,
  valid_duration: string | null,
  floating_timeout: number,
  max_transfers: number,
  can_borrow: boolean,
  max_borrow_time: number,
  start_date: string | null,
  is_air_gapped: boolean,
  license_template_id: number | null,
  validity_period: string | null,
  subscription_id: string,
  enable_maintenance_period: boolean,
  is_floating_cloud: boolean,
  is_floating: boolean,
  floating_users: number,
  is_trial: boolean,
  trial_days: number,
  prevent_vm: boolean,
  metadata: Record<string, any>,
  is_hardware_key_auth: boolean,
  order_id: number,
  LicenseCustomFields: {
    product_custom_field_id: number;
    value: string | undefined;
  }[],
  LicenseProductFeatures: {
    id: number,
    allow_negative_consumptions: boolean,
    allow_overages: boolean,
    allow_unlimited_consumptions: boolean,
    consumption_period?: string,
    expiry_date: string | null,
    floating_timeout: number,
    floating_users?: number,
    is_floating_cloud?: boolean,
    is_floating?: boolean,
    max_consumption: number,
    max_overages: number,
    metadata: Record<string, any>,
    name?: string,
    product_feature_id: number,
    reset_consumption: boolean,
  }[],
};

enum LicenseTypes {
  perpetual = 'perpetual',
  time_limited = 'time-limited',
  consumption = 'consumption',
  subscription = 'subscription',
};
﻿
Bundle Order Response
TypeScript
JSON Schema
Example response
type BundleOrderResponse = {
  order_id: string,
  order_items: [
    {
      id: number,
      product_id: number,
      Licenses: License[],
    }
  ],
  new_passwords: { email: string, password: string }[],
}

type License = BundleLicense | SubLicense;

type BundleLicense = LicenseCommon & {
  order_id: number,
  note?: string,
  is_bundle: true,
  time_activated?: number,
} & ({
  license_key: string;
  users: never;
  max_license_users: never;
} | {
  license_key: never;
  users: {
    email: string,
    first_name?: string,
    last_name?: string,
    phone_number?: string,
    is_manager: boolean,
  }[];
  max_license_users: number;
});

type SubLicense = LicenseCommon & {
  order_id: number,
  note?: string,
  bundle_license_id: number,
  LicenseCustomFields: {
    product_custom_field_id: number;
    value: string | undefined;
  }[],
  LicenseProductFeatures: {
    id: number,
    allow_negative_consumptions: boolean,
    allow_overages: boolean,
    allow_unlimited_consumptions: boolean,
    consumption_period?: string,
    expiry_date: string | null,
    floating_timeout: number,
    floating_users?: number,
    is_floating_cloud?: boolean,
    is_floating?: boolean,
    max_consumption: number,
    max_overages: number,
    metadata: Record<string, any>,
    name?: string,
    product_feature_id: number,
    reset_consumption: boolean,
  }[],
}

type LicenseCommon = {
  id: number;
  active: boolean;
  allow_unlimited_activations: boolean;
  can_borrow: boolean;
  created_at: number;
  enabled: boolean;
  floating_timeout: number;
  floating_users: number;
  is_air_gapped: boolean;
  is_floating_cloud: boolean;
  is_floating: boolean;
  is_hardware_key_auth: boolean;
  is_trial: boolean;
  license_template_id?: number | null;
  max_activations: number;
  max_borrow_time: number;
  max_transfers: number;
  metadata: Record<string, any>;
  prevent_vm: boolean;
  product_id: number;
  start_date: string | null;
  subscription_id: string;
  trial_days: number;
  updated_at: number;
  valid_duration: string | null;
  validity_period?: string;
} & ({
  license_type: 'perpetual'
} | {
  license_type: 'subscription';
  allow_grace_period: boolean;
  grace_period: number;
  time_activated: number;
} | {
  license_type: 'consumption';
  allow_negative_consumptions: boolean;
  allow_overages: boolean;
  allow_unlimited_consumptions: boolean;
  consumption_period: string | null;
  max_consumptions: number;
  max_overages: number;
  reset_consumption: boolean;
} | {
  license_type: 'time-limited'
}) & ({
  enable_maintenance_period: false;
} | {
  enable_maintenance_period: true;
  maintenance_duration: string;
  maintenance_period?: string | null;
});

enum LicenseTypes {
  perpetual = 'perpetual',
  time_limited = 'time-limited',
  consumption = 'consumption',
  subscription = 'subscription',
};

type BundleOrderResponse = {
  order_id: string,
  order_items: [
    {
      id: number,
      product_id: number,
      Licenses: License[],
    }
  ],
  new_passwords: { email: string, password: string }[],
}

type License = BundleLicense | SubLicense;

type BundleLicense = LicenseCommon & {
  order_id: number,
  note?: string,
  is_bundle: true,
  time_activated?: number,
} & ({
  license_key: string;
  users: never;
  max_license_users: never;
} | {
  license_key: never;
  users: {
    email: string,
    first_name?: string,
    last_name?: string,
    phone_number?: string,
    is_manager: boolean,
  }[];
  max_license_users: number;
});

type SubLicense = LicenseCommon & {
  order_id: number,
  note?: string,
  bundle_license_id: number,
  LicenseCustomFields: {
    product_custom_field_id: number;
    value: string | undefined;
  }[],
  LicenseProductFeatures: {
    id: number,
    allow_negative_consumptions: boolean,
    allow_overages: boolean,
    allow_unlimited_consumptions: boolean,
    consumption_period?: string,
    expiry_date: string | null,
    floating_timeout: number,
    floating_users?: number,
    is_floating_cloud?: boolean,
    is_floating?: boolean,
    max_consumption: number,
    max_overages: number,
    metadata: Record<string, any>,
    name?: string,
    product_feature_id: number,
    reset_consumption: boolean,
  }[],
}

type LicenseCommon = {
  id: number;
  active: boolean;
  allow_unlimited_activations: boolean;
  can_borrow: boolean;
  created_at: number;
  enabled: boolean;
  floating_timeout: number;
  floating_users: number;
  is_air_gapped: boolean;
  is_floating_cloud: boolean;
  is_floating: boolean;
  is_hardware_key_auth: boolean;
  is_trial: boolean;
  license_template_id?: number | null;
  max_activations: number;
  max_borrow_time: number;
  max_transfers: number;
  metadata: Record<string, any>;
  prevent_vm: boolean;
  product_id: number;
  start_date: string | null;
  subscription_id: string;
  trial_days: number;
  updated_at: number;
  valid_duration: string | null;
  validity_period?: string;
} & ({
  license_type: 'perpetual'
} | {
  license_type: 'subscription';
  allow_grace_period: boolean;
  grace_period: number;
  time_activated: number;
} | {
  license_type: 'consumption';
  allow_negative_consumptions: boolean;
  allow_overages: boolean;
  allow_unlimited_consumptions: boolean;
  consumption_period: string | null;
  max_consumptions: number;
  max_overages: number;
  reset_consumption: boolean;
} | {
  license_type: 'time-limited'
}) & ({
  enable_maintenance_period: false;
} | {
  enable_maintenance_period: true;
  maintenance_duration: string;
  maintenance_period?: string | null;
});

enum LicenseTypes {
  perpetual = 'perpetual',
  time_limited = 'time-limited',
  consumption = 'consumption',
  subscription = 'subscription',
};
﻿
Licenses
Each entry in the items array specifies a product code and a list of licenses being associated to that product. The following examples show a minimal order request payload for key-based and user-based licenses:
Key-based license order
User-based license order
{
    "id": "id_1546606209296",
    "items": [
        {
            "product_code": "TT",
            "licenses": [
                {
                    "users": [{
                        "email": "[email protected]",
                        "is_manager": false
                    }]
                }
            ]
        }
    ]
}
{
    "id": "id_1546606209296",
    "items": [
        {
            "product_code": "TT",
            "licenses": [
                {
                    "users": [{
                        "email": "end-user@gmail.com",
                        "is_manager": false
                    }]
                }
            ]
        }
    ]
}
﻿
For each license you can specify a policy_code within the license object which will assign properties to a license based on the specified License Policy. (For more details on these properties, see the next section). If no policy code is specified, the default license policy defined for the Product will be used.
You can also explicitly specify license properties which will override the License Policy values. For example:
JSON
{
    "id": "id_1546606209296",
    "items": [
        {
            "product_code": "TT",
            "licenses": [
                {
                    "key": "123-123-123-123-123",
                    "policy_code": "policy_A",
                    "max_activations": 10
                }
            ]
        }
    ]
}
{
    "id": "id_1546606209296",
    "items": [
        {
            "product_code": "TT",
            "licenses": [
                {
                    "key": "123-123-123-123-123",
                    "policy_code": "policy_A",
                    "max_activations": 10
                }
            ]
        }
    ]
}
﻿
In the above example, all License properties for the created license will be taken from the License Policy "policy_A", with the exception of the max_activations property which was explicitly specified in the order request payload.
Authorization methods: Key-based vs. User-based licenses
Each product you create in the system allows for one of two possible license authorization methods:
Key-based: clients interacting with the license are required to provide a license key in their request
User-based: clients interacting with the license are required to provide user credentials in their request
When sending an order creation request, the authorization method of licenses in the request are determined by each license's product.
When creating key-based licenses in an order, you can provide a license key in the key property of the license. This is optional, and if omitted our system will generate a unique license key which will be returned to you in the order creation response object.
When creating user-based licenses in an order, you must specify the users (1 or more) attached to that license by specifying them in a list in the users property of the license.
Additional license properties
max_activations - maximum number of time this license can be activated. If not set, product max activations is being used if defined for the product, if not - default value of 1 activation is being used.
license_type - type of license - value can be either time-limited,  perpetual consumption or subscription. If it is a time limited license, valid_duration should also be set for the license. If it is perpetual license then valid duration does not apply and if consumption, max_consumptions is being used and should be set in order, if not, product max consumptions is being used.
For subscription licenses, LicenseSpring requires an integration to an external source of truth (like a recurring billing system). LicenseSpring updates the status of the license according to the status of the subscription, which is handled by a 3rd party. Without this integration, subscription licenses remain valid until otherwise specified
max_consumptions - used in pair with consumption license_type - defines how many times product can be used within the license.
valid_duration - defines how long license should be valid - value examples: 1y (one year) or 2m (2 months) or 3d (3 days) or 4h (4 hours) or 5min (5 minutes).
enable_maintenance_duration - whether license should consider maintenance duration, used in pair with maintenance_duration.
start_date - start date of license "2024-03-12"
maintenance_duration - duration of license maintenance period -  value examples: 1y (one year) or 2m (2 months) or 3d (3 days).
validity_period - final end date and time license is valid.
product_features - array of additional product features
shorter version with product feature code only: ["feature1", "feature2"]
longer version, suitable for consumption features: [{code: "feature_code", max_consumption:33}].
is_trial - boolean, defaults to False - whether this is a trial license or not.
prevent_vm - boolean, defaults to False - whether license should be allowed on virtual machines.
max_transfers - integer, defaults to 0 (Device transfer not allowed) - limit of license transfers between different devices.
For user-based licenses, instead of a license key, user is assigned as an object:
email - required, email of the license user
is_manager - optional (default false), if this user is license manager for all licenses in this order
Only for consumption licenses:
allow_overages - boolean, defaults to False - whether license should allow overage license usage regardless the consumption, value example: true or false
max_overages - number, maximum overage of consumption over the max_consumption.
reset_consumption - boolean, defaults to False, whether license consumption my be reset, value example: true or false
consumption_period - period over which licenses are reset - week, month or year
Bundle Product Orders
LicenseSpring allows for products to be bundled, and the two types of products discussed in this article respective to bundling are:
Non-bundle products (default) - these are singular products where each license is attached to one product. Clients interacting with these licenses use the following endpoints on the License API:
﻿Activate License (Online Method)﻿ 
﻿Activate License (Offline Method)﻿ 
﻿Check License﻿ 
﻿Deactivate Bundle (Online Method)﻿ 
﻿Deactivate License (Offline Method)﻿ 
Bundle products - these are products that contain multiple products within. The system creates a license for both the bundle itself and the products contained in the bundle. Activating/deactivating the top-level bundle license also activates/deactivates the licenses included within the bundle. Clients interacting with these licenses use the following endpoints on the License API:
﻿Activate Bundle (Online Method)﻿ 
﻿Activate Bundle (Offline Method)﻿ 
﻿Check Bundle﻿ 
﻿Deactivate Bundle (Online Method)﻿ 
﻿Deactivate Bundle (Offline Method)﻿ 
A Bundle Order contains multiple products linked to a single Bundle Product. To create a Bundle Order, you have to set the is_bundle property, and the products within the bundle are explicitly specified within each License object, as in the following examples:
Bundle of key-based licenses
Bundle of user-based licenses
{
    "id": "2cdf5739334b4688b04c4bbfb3da89618",
    "is_bundle": true,
    "append": false,
    "customer": null,
    "items": [
        {
            "product_code": "drama", // bundle product code
            "key": "GP14Q-QA4Z-M6SK-CXBU",
            "users": [],
            "licenses": [
                {
                    "policy_code": "dftlp", // the deprecated name for this attribute is "license_template_code"
                    "product_code": "p"
                },
                {
                    "policy_code": "dftlp",
                    "product_code": "p34"
                }
            ]
        }
    ],
    "reference": ""
}
{
    "id": "2cdf5739334b4688b04c4bbfb3da89618",
    "is_bundle": true,
    "append": false,
    "customer": null,
    "items": [
        {
            "product_code": "drama", // bundle product code
            "key": "GP14Q-QA4Z-M6SK-CXBU",
            "users": [],
            "licenses": [
                {
                    "policy_code": "dftlp", // the deprecated name for this attribute is "license_template_code"
                    "product_code": "p"
                },
                {
                    "policy_code": "dftlp",
                    "product_code": "p34"
                }
            ]
        }
    ],
    "reference": ""
}
﻿
For Bundle Orders, the policy_code property is mandatory
For Bundle Orders, the policy_code property has an alternate name: license_template_code. Both function identically, though the license_template_code name is considered deprecated on the API
﻿
Delete Installation File
Retrieve Order