Get Product Details

Endpoint

• Method: GET
• Path: /api/v4/product_details
• Description: Returns metadata and flags for a product.

Authentication

See License API Authorization.

Required headers

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

Recommended headers

• Accept: application/json

Request

Query parameters

Required:

• product (string) — Product short code

Optional:

• include_latest_version (boolean) — Default: false
• include_custom_fields (boolean) — Default: false
• env (string) — Filter by installation file environment

Examples

curl

curl --location --request GET '/api/v4/product_details?product=string' \
--header 'Accept: application/json' \
--header 'Date: string' \
--header 'Authorization: string'

nodejs

var request = require('request');
var options = {
  method: 'GET',
  url: '/api/v4/product_details?product=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/product_details?product=string", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));

python

import requests

url = "/api/v4/product_details?product=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/product_details?product=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

Schema

Request schema (TypeScript + JSON Schema)

TypeScript

type ProductDetailsRequestParameters = {
  
  // required parameters:
  product: string,
  
  // optional parameters:
  include_latest_version?: boolean | undefined,
  include_custom_fields?: boolean | undefined,
  env?: string | undefined,
}

JSON Schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "product": { "type": "string" },
    "include_latest_version": { "type": "boolean" },
    "include_custom_fields": { "type": "boolean" },
    "env": { "type": "string" }
  },
  "required": ["product"],
  "additionalProperties": false
}

Response schema (TypeScript + JSON Schema)

TypeScript

type ProductDetailsResponseBody = {
    product_id: number;
    product_name: string;
    short_code: string;
    authorization_method: "license-key" | "user";
    floating_timeout: number;
    max_overages: number;
    trial_days: number;
    allow_overages: boolean;
    allow_trial: boolean;
    prevent_vm: boolean;
    metadata: JSON;
    
    // this property is only present if "include_custom_fields" query param is true
    custom_fields?: {
        id: number;
        name: string;
        default_value: string;
    }[] | undefined;
    
    // this property is only present if "include_latest_version" query param is true
    latest_version?: {
        version: string | null;
        environment: string | null;
        hash_md5: string | null;
        eula_link: string | null;
        release_notes_link: string | null;
        size: string | null;
        requires_version: string | null;
        channel: string | null;
        release_date: string | null;
        id: number;
        product_id: number;
        enabled: boolean;
        full_link: string | null;
        filename: string | null;
        created_at: string;
        updated_at: string;
    } | undefined;
}

JSON Schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "product_id": { "type": "number" },
    "product_name": { "type": "string" },
    "short_code": { "type": "string" },
    "authorization_method": { "type": "string", "enum": ["license-key", "user"] },
    "metadata": { "type": "object" },
    "custom_fields": { "type": "array" },
    "latest_version": { "type": ["object", "null"] }
  },
  "required": ["product_id", "product_name", "short_code", "authorization_method", "metadata"],
  "additionalProperties": true
}

{% hint style="info" %} If product does not have a version defined, it will return null {% endhint %}

{% hint style="info" %} If product does not have any custom fields defined, it will return an empty array {% endhint %}

Errors

If an error occurs, the response will have an HTTP status code of 400 or higher, and 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

unknown_product (400)

Provided product was not found

missing_headers (400)

Some headers are missing

missing_parameters (400)

Some parameters are missing in the request: { params }