Studio DRM API

The Studio DRM API, which is a versioned API, contains the following endpoints:

Base URL

Use the following base URL:

Create / Update Studio DRM Policy Configuration

This endpoint allows the following actions:

• Create a Studio DRM policy configuration.

• Update an existing Studio DRM policy configuration.

  An existing Studio DRM policy configuration will be updated when either of the following conditions are true:

  • The _id parameter is set to the system-defined ID of an existing Studio DRM policy configuration.
  • The value assigned to the policy_name parameter matches the name assigned to an existing Studio DRM policy configuration.

Request

Request syntax:

Request body parameters:

Pass the following request body parameters:

Policy settings that are not explicitly set are defined by the default Studio DRM policy. If you are updating an existing Studio DRM policy configuration, then those settings will be overwritten by the default Studio DRM policy.

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters.

Sample Request/Response

Call the create_studio_drm_pc module (Python 3) to create a Studio DRM policy configuration. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class DRMPolicies:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Create a DRM policy.
        """
        self._create_or_update_drm_policy()
 
    def _create_or_update_drm_policy(self):
 
        policy_data = dict()
        url = "{}{}".format(self.host, "/api/v3/drm/policies/create-or-update")
 
        new_policy_data = {
            'policy_name': 'My First Policy',
            'widevine': {
                'content_key_specs': [
                    {
                        'track_type': 'ALL',
                        'security_level': 1,
                        'required_output_protection': {
                            'hdcp': 'HDCP_NONE'
                        }
                    }
                ],
                'policy_overrides': {
                    'can_persist': True,
                    'can_play': True,
                    'can_renew': True
                }
            },
            'fairplay': {
                "hd": {
                    'allow_airplay': False,
                    'allow_av_adapter': False
                }
            },
            'playready': {
                "hd": {
                    'require_hdcp_type_1': True,
                    'digital_video_protection_level': 250
                },
                "uhd1": {
                    'require_hdcp_type_1': True,
                    'digital_video_protection_level': 250
                },
                "uhd2": {
                    'require_hdcp_type_1': True,
                    'digital_video_protection_level': 250
                }
            }
        }
 
        policy_data['item'] = new_policy_data
 
        response = requests.post(
            url, data=APIParams(APICredentials()).get_params(policy_data)
        )
 
        print(response.json())
 
DRMPolicies().run()

Response:

{
	'configs': [{
			'_id': 'abcdef123456ghijkl7890123mno789',
			'created': 1558566151978,
			'policy_name': 'My First Policy',
			'fairplay': {
				'key_duration_seconds': 0,
				'hd': {
					'hdcp_enforcement': -1,
					'allow_airplay': False,
					'allow_av_adapter': False
				},
				'persistence_duration_seconds': 0,
				'rental_duration_seconds': 0,
				'lease_duration_seconds': 0,
				'uhd2': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'uhd1': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'playback_duration_seconds': 0,
				'sd': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'rental': False,
				'persistence': False,
				'lease': False
			},
			'lmsig': '1538693547862491_10735_4271',
			'widevine': {
				'content_key_specs': [{
						'track_type': 'ALL',
						'security_level': 1,
						'required_output_protection': {
							'hdcp_srm_rule': 'HDCP_SRM_RULE_NONE',
							'hdcp': 'HDCP_NONE',
							'cgms_flags': 'CGMS_NONE',
							'disable_analog_output': False
						}
					}
				],
				'policy_overrides': {
					'renewal_retry_interval_seconds': 0,
					'can_renew': True,
					'can_persist': True,
					'license_duration_seconds': 86400,
					'always_include_client_id': False,
					'can_play': True,
					'rental_duration_seconds': 0,
					'renewal_delay_seconds': 0,
					'renewal_recovery_duration_seconds': 0,
					'playback_duration_seconds': 0,
					'renew_with_usage': False
				}
			},
			'owner': 'abc33864a92c46a1a286cdd49b0a9123',
			'playready': {
				'license_duration_seconds': 86400,
				'can_persist': False,
				'can_play': True,
				'uhd2': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'uhd1': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'playback_duration_seconds': 0,
				'hd': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'sd': {
					'require_hdcp_type_1': False,
					'security_level': 2000,
					'play_enabler': False,
					'digital_video_protection_level': 100
				}
			},
			'lastmod': 1558566152020
		}
	],
	'error': 0
}

Delete Studio DRM Policy Configuration

Deletes a specific Studio DRM policy configuration.

Request

Request syntax:

Define the following variable when submitting the above request:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters.

Sample Request/Response

Update the delete_studio_drm_pc module to identify the Studio DRM policy configuration that will be deleted by its system-defined ID.

        policy_id = 'abcdef123456ghijkl7890123mno456'

Call the delete_studio_drm_pc module (Python 3) to delete a specific Studio DRM policy configuration. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class DRMPolicies:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Delete a DRM policy.
        """
        self._delete_drm_policy()
 
    def _delete_drm_policy(self):
        policy_id = 'abcdef123456ghijkl7890123mno456'
        url = "{}{}{}".format(self.host, "/api/v3/drm/policy/", policy_id)
 
        response = requests.delete(
            url, params=APIParams(APICredentials()).get_params({})
        )
 
        print(response.json())
 
DRMPolicies().run()

Response:

{
	'configs': [{
			'_id': 'abcdef123456ghijkl7890123mno789',
			'created': 1558566151978,
			'policy_name': 'My First Policy',
			'fairplay': {
				'key_duration_seconds': 0,
				'hd': {
					'hdcp_enforcement': -1,
					'allow_airplay': False,
					'allow_av_adapter': False
				},
				'persistence_duration_seconds': 0,
				'rental_duration_seconds': 0,
				'lease_duration_seconds': 0,
				'uhd2': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'uhd1': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'playback_duration_seconds': 0,
				'sd': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'rental': False,
				'persistence': False,
				'lease': False
			},
			'lmsig': '1538693547862491_10735_4271',
			'widevine': {
				'content_key_specs': [{
						'track_type': 'ALL',
						'security_level': 1,
						'required_output_protection': {
							'hdcp_srm_rule': 'HDCP_SRM_RULE_NONE',
							'hdcp': 'HDCP_NONE',
							'cgms_flags': 'CGMS_NONE',
							'disable_analog_output': False
						}
					}
				],
				'policy_overrides': {
					'renewal_retry_interval_seconds': 0,
					'can_renew': True,
					'can_persist': True,
					'license_duration_seconds': 86400,
					'always_include_client_id': False,
					'can_play': True,
					'rental_duration_seconds': 0,
					'renewal_delay_seconds': 0,
					'renewal_recovery_duration_seconds': 0,
					'playback_duration_seconds': 0,
					'renew_with_usage': False
				}
			},
			'owner': 'abc33864a92c46a1a286cdd49b0a9123',
			'playready': {
				'license_duration_seconds': 86400,
				'can_persist': False,
				'can_play': True,
				'uhd2': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'uhd1': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'playback_duration_seconds': 0,
				'hd': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'sd': {
					'require_hdcp_type_1': False,
					'security_level': 2000,
					'play_enabler': False,
					'digital_video_protection_level': 100
				}
			},
			'lastmod': 1558566152020
		}
	],
	'error': 0
}

Get All Studio DRM Policy Configurations

Retrieves all Studio DRM policy configurations associated with your user account.

Request

Request syntax:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Call the get_all_studio_drm_pc module (Python 3) to retrieve a list of Studio DRM policy configurations. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class DRMPolicies:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Retrieve all DRM policies.
        """
        self._get_drm_policies()
 
    def _get_drm_policies(self):
        url = "{}{}".format(self.host, "/api/v3/drm/policies")
 
        response = requests.get(
            url, params=APIParams(APICredentials()).get_params({})
        )
 
        print(response.json())
 
DRMPolicies().run()

Response:

{
	'configs': [{
			'_id': 'abcdef123456ghijkl7890123mno789',
			'created': 1558566151978,
			'policy_name': 'My First Policy',
			'fairplay': {
				'key_duration_seconds': 0,
				'hd': {
					'hdcp_enforcement': -1,
					'allow_airplay': False,
					'allow_av_adapter': False
				},
				'persistence_duration_seconds': 0,
				'rental_duration_seconds': 0,
				'lease_duration_seconds': 0,
				'uhd2': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'uhd1': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'playback_duration_seconds': 0,
				'sd': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'rental': False,
				'persistence': False,
				'lease': False
			},
			'lmsig': '1538693547862491_10735_4271',
			'widevine': {
				'content_key_specs': [{
						'track_type': 'ALL',
						'security_level': 1,
						'required_output_protection': {
							'hdcp_srm_rule': 'HDCP_SRM_RULE_NONE',
							'hdcp': 'HDCP_NONE',
							'cgms_flags': 'CGMS_NONE',
							'disable_analog_output': False
						}
					}
				],
				'policy_overrides': {
					'renewal_retry_interval_seconds': 0,
					'can_renew': True,
					'can_persist': True,
					'license_duration_seconds': 86400,
					'always_include_client_id': False,
					'can_play': True,
					'rental_duration_seconds': 0,
					'renewal_delay_seconds': 0,
					'renewal_recovery_duration_seconds': 0,
					'playback_duration_seconds': 0,
					'renew_with_usage': False
				}
			},
			'owner': 'abc33864a92c46a1a286cdd49b0a9123',
			'playready': {
				'license_duration_seconds': 86400,
				'can_persist': False,
				'can_play': True,
				'uhd2': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'uhd1': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'playback_duration_seconds': 0,
				'hd': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'sd': {
					'require_hdcp_type_1': False,
					'security_level': 2000,
					'play_enabler': False,
					'digital_video_protection_level': 100
				}
			},
			'lastmod': 1558566152020
		}
	],
	'error': 0
}  

Get Studio DRM Policy Configuration

Retrieves a specific Studio DRM policy configuration.

Request

Request syntax:

Define the following variable when submitting the above request:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Update the get_studio_drm_pc module to identify the policy that will be retrieved by its system-defined ID.

        policy_id = 'abcdef123456ghijkl7890123mno789'

Call the get_studio_drm_pc module (Python 3) to retrieve a specific Studio DRM policy configuration. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams 
 
class DRMPolicy:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Retrieve a DRM policy.
        """
        self._get_drm_policy()
 
    def _get_drm_policy(self):
        policy_id = 'abcdef123456ghijkl7890123mno789'
        url = "{}{}{}".format(self.host, "/api/v3/drm/policy/", policy_id)
 
        response = requests.get(
            url, params=APIParams(APICredentials()).get_params({})
        )
 
        print(response.json())
 
DRMPolicy().run()

Response:

{
	'configs': [{
			'_id': 'abcdef123456ghijkl7890123mno789',
			'created': 1558566151978,
			'policy_name': 'My First Policy',
			'fairplay': {
				'key_duration_seconds': 0,
				'hd': {
					'hdcp_enforcement': -1,
					'allow_airplay': False,
					'allow_av_adapter': False
				},
				'persistence_duration_seconds': 0,
				'rental_duration_seconds': 0,
				'lease_duration_seconds': 0,
				'uhd2': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'uhd1': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'playback_duration_seconds': 0,
				'sd': {
					'hdcp_enforcement': -1,
					'allow_airplay': True,
					'allow_av_adapter': True
				},
				'rental': False,
				'persistence': False,
				'lease': False
			},
			'lmsig': '1538693547862491_10735_4271',
			'widevine': {
				'content_key_specs': [{
						'track_type': 'ALL',
						'security_level': 1,
						'required_output_protection': {
							'hdcp_srm_rule': 'HDCP_SRM_RULE_NONE',
							'hdcp': 'HDCP_NONE',
							'cgms_flags': 'CGMS_NONE',
							'disable_analog_output': False
						}
					}
				],
				'policy_overrides': {
					'renewal_retry_interval_seconds': 0,
					'can_renew': True,
					'can_persist': True,
					'license_duration_seconds': 86400,
					'always_include_client_id': False,
					'can_play': True,
					'rental_duration_seconds': 0,
					'renewal_delay_seconds': 0,
					'renewal_recovery_duration_seconds': 0,
					'playback_duration_seconds': 0,
					'renew_with_usage': False
				}
			},
			'owner': 'abc33864a92c46a1a286cdd49b0a9123',
			'playready': {
				'license_duration_seconds': 86400,
				'can_persist': False,
				'can_play': True,
				'uhd2': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'uhd1': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'playback_duration_seconds': 0,
				'hd': {
					'digital_video_protection_level': 250,
					'security_level': 2000,
					'play_enabler': False,
					'require_hdcp_type_1': True
				},
				'sd': {
					'require_hdcp_type_1': False,
					'security_level': 2000,
					'play_enabler': False,
					'digital_video_protection_level': 100
				}
			},
			'lastmod': 1558566152020
		}
	],
	'error': 0
}

configs List

The configs list describes one or more Studio DRM policy configurations using the following parameters:

Apple FairPlay Streaming

The fairplay dictionary describes Apple FairPlay Streaming DRM policies.

Resolution Dictionary

Each of the above dictionaries contains the following parameters that describe the Apple FairPlay Streaming DRM policy for that resolution:

Google Widevine DRM

The widevine dictionary contains the following parameters that describe a Google Widevine DRM policy:

{
	'can_renew': False,
	'renewal_retry_interval_seconds': 0,
	'always_include_client_id': False,
	'license_duration_seconds': 86400,
	'can_persist': False,
	'can_play': True,
	'rental_duration_seconds': 0,
	'renewal_delay_seconds': 0,
	'renewal_recovery_duration_seconds': 0,
	'playback_duration_seconds': 0,
	'renew_with_usage': False
}

policy_overrides Dictionary

The policy_overrides dictionary defines the Studio DRM policy that will be used instead of policies assigned directly to an asset.

content_key_specs List

The content_key_specs list defines Studio DRM policy on a per track basis.

Microsoft PlayReady

The playready dictionary describes resolution-specific Microsoft PlayReady DRM policies.

Resolution Dictionary

Each of the above dictionaries contains the following parameters that describe the Microsoft PlayReady DRM policy for that resolution:

Default Policy

Policy settings that are not explicitly set are defined according to the following default Studio DRM policy:

...
	'fairplay': {
		'key_duration_seconds': 0,
		'hd': {
			'hdcp_enforcement': -1,
			'allow_airplay': True,
			'allow_av_adapter': True
		},
		'persistence_duration_seconds': 0,
		'rental_duration_seconds': 0,
		'lease_duration_seconds': 0,
		'uhd2': {
			'hdcp_enforcement': -1,
			'allow_airplay': True,
			'allow_av_adapter': True
		},
		'uhd1': {
			'hdcp_enforcement': -1,
			'allow_airplay': True,
			'allow_av_adapter': True
		},
		'playback_duration_seconds': 0,
		'sd': {
			'hdcp_enforcement': -1,
			'allow_airplay': True,
			'allow_av_adapter': True
		},
		'rental': False,
		'persistence': False,
		'lease': False
	},
	'widevine': {
		'content_key_specs': [{
				'track_type': 'ALL',
				'required_output_protection': {
					'hdcp_srm_rule': 'HDCP_SRM_RULE_NONE',
					'hdcp': 'HDCP_NONE',
					'cgms_flags': 'CGMS_NONE',
					'disable_analog_output': False
				},
				'security_level': 1
			}
		],
		'policy_overrides': {
			'can_renew': False,
			'renewal_retry_interval_seconds': 0,
			'always_include_client_id': False,
			'license_duration_seconds': 86400,
			'can_persist': False,
			'can_play': True,
			'rental_duration_seconds': 0,
			'renewal_delay_seconds': 0,
			'renewal_recovery_duration_seconds': 0,
			'playback_duration_seconds': 0,
			'renew_with_usage': False
		}
	},
	'playready': {
		'license_duration_seconds': 86400,
		'can_persist': False,
		'realtime_expiration': True,
		'can_play': True,
		'uhd2': {
			'require_hdcp_type_1': False,
			'security_level': 2000,
			'play_enabler': False,
			'analog_video_protection_level': 100,
			'compressed_digital_audio_protection_level': 100,
			'uncompressed_digital_audio_protection_level': 100,
			'digital_video_protection_level': 100
		},
		'uhd1': {
			'require_hdcp_type_1': False,
			'security_level': 2000,
			'play_enabler': False,
			'analog_video_protection_level': 100,
			'compressed_digital_audio_protection_level': 100,
			'uncompressed_digital_audio_protection_level': 100,
			'digital_video_protection_level': 100
		},
		'playback_duration_seconds': 0,
		'hd': {
			'require_hdcp_type_1': False,
			'security_level': 2000,
			'play_enabler': False,
			'analog_video_protection_level': 100,
			'compressed_digital_audio_protection_level': 100,
			'uncompressed_digital_audio_protection_level': 100,
			'digital_video_protection_level': 100
		},
		'sd': {
			'require_hdcp_type_1': False,
			'security_level': 2000,
			'play_enabler': False,
			'analog_video_protection_level': 100,
			'compressed_digital_audio_protection_level': 100,
			'uncompressed_digital_audio_protection_level': 100,
			'digital_video_protection_level': 100
		}
	}
...

Update Policy Sample Scenario

In this scenario, a Studio DRM policy starts off with the following Microsoft PlayReady settings:

...
	"playready": {
		"license_duration_seconds": 43200,
		"can_persist": true,
		"can_play": true,
		"playback_duration_seconds": 50,
		"sd": {			
			"require_hdcp_type_1": false,
			"security_level": 2000,
			"play_enabler": false,
			"digital_video_protection_level": 100
	},
...	

The policy is then updated as indicated below.

...
	"playready": {
		"license_duration_seconds": 50000
...	

The above playready dictionary is missing various settings. Although those settings have been previously defined, they will now be overwritten by the corresponding default settings. As a result, the Microsoft PlayReady configuration will be defined as indicated below.

...
	'playready': {
		'license_duration_seconds': 50000,
		'can_persist': False,
		'realtime_expiration': True,
		'can_play': True,
		'uhd2': {
			'digital_video_protection_level': 100,
			'analog_video_protection_level': 100,
			'compressed_digital_audio_protection_level': 100,
			'security_level': 2000,
			'uncompressed_digital_audio_protection_level': 100,
			'require_hdcp_type_1': False,
			'play_enabler': False
		},
		'uhd1': {
			'digital_video_protection_level': 100,
			'analog_video_protection_level': 100,
			'compressed_digital_audio_protection_level': 100,
			'security_level': 2000,
			'uncompressed_digital_audio_protection_level': 100,
			'require_hdcp_type_1': False,
			'play_enabler': False
		},
		'license_begin_seconds': 3600,
		'playback_duration_seconds': 0,
		'hd': {
			'digital_video_protection_level': 100,
			'analog_video_protection_level': 100,
			'compressed_digital_audio_protection_level': 100,
			'security_level': 2000,
			'uncompressed_digital_audio_protection_level': 100,
			'require_hdcp_type_1': False,
			'play_enabler': False
		},
		'sd': {
			'digital_video_protection_level': 100,
			'analog_video_protection_level': 100,
			'compressed_digital_audio_protection_level': 100,
			'security_level': 2000,
			'uncompressed_digital_audio_protection_level': 100,
			'require_hdcp_type_1': False,
			'play_enabler': False
		}
	},
...

Get VMP Rejection Status Configuration

Retrieves the set of Verified Media Path (VMP) status(es) that will cause the rejection of a license request.

Please refer to Widevine License SDK documentation for more information on VMP status.

Request

Request syntax:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Call the get_vmp_rejection_status_configuration module (Python 3) to retrieve your VMP status configuration. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class VMPStatus:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Retrieve VMP status configuration.
        """
        self._get_vmp_status_configuration()
 
    def _get_vmp_status_configuration(self):
        url = "{}{}".format(self.host, "/api/v3/drm/vmp-reject-statuses")
 
        response = requests.get(
            url, params=APIParams(APICredentials()).get_params({})
        )
 
        print(response.json())
 
VMPStatus().run()

Response:

{
	'vmp_reject_statuses': [],
	'error': 0
}

Update VMP Rejection Status Configuration

Defines the set of Verified Media Path (VMP) status(es) that will cause the rejection of a license request.

Please refer to Widevine License SDK documentation for more information on VMP status.

Request

Request syntax:

Request body parameters:

Pass the following request body parameters:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Call the update_vmp_rejection_status_configuration module (Python 3) to update your VMP status configuration. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class VMPStatusUpdate:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Updates the set of VMP rejection statuses.
        """
        self._update_vmp_status_configuration()
 
    def _update_vmp_status_configuration(self):

        vmp_data = dict()
        url = "{}{}".format(self.host, "/api/v3/drm/vmp-reject-statuses/update")
 
        new_vmp_data = {
            'vmp_reject_statuses': ['PLATFORM_UNVERIFIED']
        }
 
        vmp_data['item'] = new_vmp_data
 
        response = requests.post(
            url, data=APIParams(APICredentials()).get_params(vmp_data)
            )
 
        print(response.json())

VMPStatusUpdate().run()

Response:

{
	"vmp_reject_statuses": [
		"PLATFORM_UNVERIFIED"
	],
	"error": 0
}

Get Static Encryption Key Status

Indicates whether the content generated by all Live Slicers will be encrypted using a static encryption key.

Request

Request syntax:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Call the get_static_encryption_key_status module (Python 3) to find out whether you may encrypt your content using a static encryption key. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class StaticEncryptionKeyStatus:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Returns whether content may be encrypted using a static encryption key.
        """
        self._get_status_encryption_key_status()
 
    def _get_status_encryption_key_status(self):
        url = "{}{}".format(self.host, "/api/v3/drm/use-static-encryption-key")
 
        response = requests.get(
            url, params=APIParams(APICredentials()).get_params({})
        )
 
        print(response.json())
 
StaticEncryptionKeyStatus().run()

Response:

{
	"use_static_encryption_key": true,
	"owner": "111222333444555666",
	"error": 0
}

Update Static Encryption Key Status

Determines whether the content generated by all Live Slicers will be encrypted using a static encryption key.

The use of a static encryption key does not affect your license acquisition workflow. However, it does mean that the same encryption key will be used until it is rotated. Use the Create / Update Static Encryption Key Rotation Schedule endpoint to define a schedule for key rotation.

Use a static encryption key when your playback platform does not support the use of multiple dynamic encryption keys.

Which endpoint should I use to configure static encryption key usage?

Set up your static encryption key configuration according to the scope to which it will be applied.

Request

Request syntax:

Request body parameters:

Pass the following request body parameters:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Call the update_static_encryption_key_status module (Python 3) to configure whether you may encrypt your content using a static encryption key. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class StaticEncryptionKeyStatusUpdate:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Updates whether content may be encrypted using a static encryption key.
        """
        self._update_status_encryption_key_status()
 
    def _update_status_encryption_key_status(self):

        static_encryption_key_status = dict()
        url = "{}{}".format(self.host, "/api/v3/drm/use-static-encryption-key/update")
 
        new_static_encryption_key_status = {
            'use_static_encryption_key': True
        }
 
        static_encryption_key_status['item'] = new_static_encryption_key_status
 
        response = requests.post(
            url, data=APIParams(APICredentials()).get_params(static_encryption_key_status) 
            )
 
        print(response.json())

StaticEncryptionKeyStatusUpdate().run()

Response:

{
	"use_static_encryption_key": true,
	"owner": "111222333444555666",
	"error": 0
}

Get Static Encryption Key Live Slicers

Retrieve the set of Live Slicers for which content will be encrypted using a static encryption key.

A static encryption key should only be used when your playback platform does not support the use of multiple dynamic encryption keys.

Request

Request syntax:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Call the get_static_encryption_key_live_slicers module (Python 3) to find out the set of Live Slicers whose content will be encrypted using a static encryption key. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class LiveSlicersStaticEncryptionKey:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Retrieves the set of Live Slicers whose content will be encrypted using a static encryption key.
        """
        self._get_live_slicers_by_status_encryption_key_status()
 
    def _get_live_slicers_by_status_encryption_key_status(self):
        url = "{}{}".format(self.host, "/api/v3/drm/static-key-slicer-ids")
 
        response = requests.get(
            url, params=APIParams(APICredentials()).get_params({})
        )
 
        print(response.json())
 
LiveSlicersStaticEncryptionKey().run()

Response:

{
	"static_key_slicer_ids": None,
	"owner": "111222333444555666",
	"error": 0
}

Update Static Encryption Key Live Slicers

Determines the set of Live Slicers whose content will be encrypted using a static encryption key.

The use of a static encryption key does not affect your license acquisition workflow. However, it does mean that the same encryption key will be used until it is rotated. Use the Create / Update Static Encryption Key Rotation Schedule endpoint to define a schedule for key rotation.

Use a static encryption key when your playback platform does not support the use of multiple dynamic encryption keys.

Which endpoint should I use to configure static encryption key usage?

Set up your static encryption key configuration according to the scope to which it will be applied.

Request

Request syntax:

Request body parameters:

Pass the following request body parameters:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Call the update_static_encryption_key_live_slicers module (Python 3) to define the set of Live Slicers whose content will be encrypted using a static encryption key. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class StaticEncryptionKeyLiveSlicersUpdate:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Defines the set of Live Slicers whose content will be encrypted using a static encryption key.
        """
        self._update_live_slicers()
 
    def _update_live_slicers(self):

        live_slicers = dict()
        url = "{}{}".format(self.host, "/api/v3/drm/static-key-slicer-ids/update")
 
        new_live_slicers = {
            'static_key_slicer_ids': ['liveslicer1', 'liveslicer2']
        }
 
        live_slicers['item'] = new_live_slicers
 
        response = requests.post(
            url, data=APIParams(APICredentials()).get_params(live_slicers) 
            )
 
        print(response.json())

StaticEncryptionKeyLiveSlicersUpdate().run()

Response:

{
	"static_key_slicer_ids": [
		"liveslicer1",
		"liveslicer2"
	],
	"owner": "111222333444555666",
	"error": 0
}

Get Static Encryption Key Rotation Schedule

Retrieve your key rotation schedule.

Request

Request syntax:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Call the get_static_encryption_key_rotation_schedule module (Python 3) to retrieve a specific Studio DRM policy configuration. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams 
 
class KeyRotationSchedule:
    def __init__(self):
        self.host = "https://services.uplynk.com"
 
    def run(self):
        """
        Retrieve your key rotation schedule.
        """
        self._get_key_rotation_schedule()
 
    def _get_key_rotation_schedule(self):
        url = "{}{}".format(self.host, "/api/v3/drm/key-rotation-schedule")
 
        response = requests.get(
            url, params=APIParams(APICredentials()).get_params({})
        )
 
        print(response.json())
 
KeyRotationSchedule().run()

Response:

{
    'owner': 'abc33864a92b12a1a2a6cdg49b0a9534',
    'key_rotation_schedule': {
        '_id': '12770715bc29840c6h2fcc45b4c6463fc',
        'next_rotation': 1576470581706,
        'hour': 20,
        'created': 1571867701666,
        'enabled': True,
        'lmsig': '1571867701666284_11829_895',
        'frequency': 1,
        'lastmod': 1571867701666,
        'unit': 'd'
    },
    'error': 0
}

Update Static Encryption Key Rotation Schedule

Define the rotation schedule for your static encryption key.

Request

Request syntax:

Request body parameters:

Pass the following request body parameters:

Authentication

Pass a digital signature based off of msg.

Learn more.

Response

The response for a successful request contains the following parameters:

Sample Request/Response

Call the update_static_encryption_key_rotation_schedule module (Python 3) to define the set of Live Slicers whose content will be encrypted using a static encryption key. This module imports names from the api_auth module.

import requests
from api_auth import APICredentials, APIParams
 
class KeyRotationSchedule:
    def __init__(self):
        self.host = "https://services.uplynk.com"

    def run(self):
        """
        Define a rotation schedule for your static encryption key.
        """
        self._update_krs()

    def _update_krs(self):
 
        krs_data = dict()
        url = "{}{}".format(self.host, "/api/v3/drm/key-rotation-schedule/create-or-update")

        new_krs_data = {
            'next_rotation': 1576470581706,
            'enabled': True,
            'frequency': 1,
            'unit': 'd',
            'hour': 20
        }

        krs_data['item'] = new_krs_data

        response = requests.post(
            url, data=APIParams(APICredentials()).get_params(krs_data)
        )

        print(response.json())

UseStaticEncryptionKeyUpdate().run()

Response:

{
    'owner': 'abc33864a92b12a1a2a6cdg49b0a9534',
    'key_rotation_schedule': {
        '_id': '12770715bc29840c6h2fcc45b4c6463fc',
        'next_rotation': 1576470581706,
        'hour': 20,
        'created': 1571867701666,
        'enabled': True,
        'lmsig': '1571940150453652_6503_3566',
        'frequency': 1,
        'lastmod': 1571940150453,
        'unit': 'd'
    },
    'error': 0
}

key_rotation_schedule Dictionary

The key_rotation_schedule dictionary describes the rotation schedule for your static key encryption.

More Information

• Studio DRM