VdoCipher

https://www.vdocipher.com/docs
Admin
VdoCipher is a video streaming and asset management platform offering RESTful APIs for playback...
Tokens:100,041
Snippets:782
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Python Dependencies

Source: https://www.vdocipher.com/docs/server/upload/file

Install the requests-toolbelt package required for multipart file uploads.

```bash
$ pip install requests-toolbelt  
```

--------------------------------

### Start Video Download

Source: https://www.vdocipher.com/docs/mobile/ios/api-reference

Begins downloading a video using authentication credentials.

```swift
func startDownload(otp: String, playbackInfo: String, videoQuality: VideoQuality? = nil)
```

```swift
func startDownload(token: String, videoQuality: VdoFramework.VdoAsset.VideoQuality? = nil)
```

--------------------------------

### CocoaPods Installation

Source: https://www.vdocipher.com/docs/mobile/ios/getting-started

Commands to add the VdoFramework to your Podfile and install it in your project.

```ruby
pod 'VdoFramework'
```

```bash
pod install
```

--------------------------------

### Get OTP with Annotations

Source: https://www.vdocipher.com/docs/server/playbackauth/anno

Examples of how to send a POST request to the VdoCipher OTP endpoint with annotation configurations.

```curl
curl -X POST \
  https://dev.vdocipher.com/api/videos/1234567890/otp \
  -H 'Accept: application/json' \
  -H 'Authorization: Apisecret a1b2c3d4e5' \
  -H 'Content-Type: application/json' \
  -d '{
  "annotate":"[{\'type\':\'rtext\', \'text\':\' {name}\', \'alpha\':\'0.60\', \'color\':\'0xFF0000\',\'size\':\'15\',\'interval\':\'5000\'}]"
}'
```

```javascript
var request = require('request');

var options = {
  method: 'POST',
  url: 'https://dev.vdocipher.com/api/videos/1234567890/otp',
  headers: {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
    'Authorization': 'Apisecret a1b2c3d4e5',
  },
  body: {
    annotate: JSON.stringify([
      {
        type: 'rtext',
        text: '{name}',
        alpha: '0.60',
        color: '0xFF0000',
        size: '15',
        interval: '5000',
      },
    ]),
  },
  json: true,
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

```php
$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://dev.vdocipher.com/api/videos/1234567890/otp",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'annotate' => json_encode([[
      'type'=>'rtext',
      'text'=>'{name}',
      'alpha'=>'0.60',
      'color'=>'0xFF0000',
      'size'=>'15',
      'interval'=>'5000'
    ]]),
  ]),
  CURLOPT_HTTPHEADER => array(
    "Accept: application/json",
    "Authorization: Apisecret a1b2c3d4e5",
    "Content-Type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```csharp
var client = new RestClient("https://dev.vdocipher.com") {
    // using user secrets to keep api key
    Authenticator = new OAuth2AuthorizationRequestHeaderAuthenticator(_config["VdoApiKey"], "Apisecret")
};
var otpParameters = new
{
    // 5 minutes until OTP is used
    // only used when setting up offline, not again
    ttl = 300,
    // watermark specified below. there can be more
    // than one object in this array
    annotate= JsonSerializer.Serialize(new [] {new {
        type= "rtext",
        text= "I am a moving text on video",
        alpha= "0.60",
        color= "0xFF0000",
        size= "15",
        interval= "5000",
    }})
};

Debug.Assert(videoId?.Length == 32, "videoId is not valid");
var url = $"/api/videos/{videoId}/otp";
var request = new RestRequest(url).AddJsonBody(otpParameters);
var cancellationToken = CancellationToken.None;
var response = await client.ExecutePostAsync(request, cancellationToken);
if (response.Content == null) return Json(new {message= "Invalid API response"});
var otpObject = JsonSerializer.Deserialize<Dictionary<string, string>>(response.Content);
// otpObject contain {otp: string, playbackInfo: string}
return Json(otpObject);
```

```python
import requests
import json

url = "https://dev.vdocipher.com/api/videos/1234567890/otp"

payload = json.dumps({
 "annotate": json.dumps([
   {'type':'rtext', 'text':'name', 'alpha':'0.60', 'color':'0xFF0000', 'size':'15','interval':'5000'}
 ])
})
headers = {
  'Authorization': "Apisecret a1b2c3d4e5",
  'Content-Type': "application/json",
  'Accept': "application/json"
}

response = requests.request("POST", url, data=payload, headers=headers)

print(response.text)
```

```ruby
require 'uri'
require 'json'
require 'net/http'

url = URI("https://dev.vdocipher.com/api/videos/1234567890/otp")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Apisecret a1b2c3d4e5'
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request.body = {
  :annotate => [{
    :type=>'rtext',
    :text=>'{name}',
    :alpha=>'0.60',
    :color=>'0xFF0000',
    :size=>'15',
    :interval=>'5000'
  }].to_json
}.to_json

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

--------------------------------

### Import Video via Ruby

Source: https://www.vdocipher.com/docs/server/upload/import-url

Example of initiating a video import using Net::HTTP in Ruby.

```ruby
require 'uri'
require 'json'
require 'net/http'
  
url = URI("https://dev.vdocipher.com/api/videos/importUrl")
  
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
  
request = Net::HTTP::Put.new(url)
request["Authorization"] = 'Apisecret a1b2c3d4e5'
request["Accept"] = 'application/json'
request["Content-Type"] = 'application/json'
request.body = ({
  :url => "{{URLString}}",
  :folderId => "{{folderID}}",
  :title => "{{videoTitle}}"
}).to_json
  
response = http.request(request)
puts response.read_body
```

--------------------------------

### Get OTP Sample Code

Source: https://www.vdocipher.com/docs/server/playbackauth/ttl

Examples for requesting an OTP with a 300-second TTL using various programming languages.

```curl
curl -X POST \
  https://dev.vdocipher.com/api/videos/1234567890/otp \
  -H 'Accept: application/json' \
  -H 'Authorization: Apisecret a1b2c3d4e5' \
  -H 'Content-Type: application/json' \
  -d '{
  "ttl":300
}'

```

```javascript
var request = require('request');

var options = {
  method: 'POST',
  url: 'https://dev.vdocipher.com/api/videos/1234567890/otp',
  headers: {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
    'Authorization': 'Apisecret a1b2c3d4e5',
  },
  body: {ttl: 300},
  json: true,
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

```

```php
$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://dev.vdocipher.com/api/videos/1234567890/otp",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    "ttl" => 300,
  ]),
  CURLOPT_HTTPHEADER => array(
    "Accept: application/json",
    "Authorization: Apisecret a1b2c3d4e5",
    "Content-Type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

```

```csharp
var client = new RestClient("https://dev.vdocipher.com/api/videos/1234567890/otp");
var request = new RestRequest(Method.POST);
request.AddHeader("Accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Apisecret a1b2c3d4e5");
request.AddParameter("undefined", "{\n\t\"ttl\":300\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);

```

```python
import requests
import json

url = "https://dev.vdocipher.com/api/videos/1234567890/otp"

payload = json.dumps({'ttl': 300})
headers = {
    'Authorization': "Apisecret a1b2c3d4e5",
    'Content-Type': "application/json",
    'Accept': "application/json"
    }

response = requests.request("POST", url, data=payload, headers=headers)

print(response.text)

```

```ruby
require 'uri'
require 'json'
require 'net/http'

url = URI("https://dev.vdocipher.com/api/videos/1234567890/otp")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Apisecret a1b2c3d4e5'
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request.body = ({:ttl => 300}).to_json

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

```

--------------------------------

### func startDownload(otp: String, playbackInfo: String, videoQuality: VideoQuality? = nil)

Source: https://www.vdocipher.com/docs/mobile/ios/api-reference

Starts the download process for the asset.

```APIDOC
## func startDownload(otp: String, playbackInfo: String, videoQuality: VideoQuality? = nil)

### Description
Initiates an offline download of the video asset.

### Parameters
- **otp** (String) - Required - The one-time password for authentication.
- **playbackInfo** (String) - Required - The playback configuration string.
- **videoQuality** (VideoQuality?) - Optional - The quality level to download.
```

--------------------------------

### Dropzone HTML Setup

Source: https://www.vdocipher.com/docs/server/upload/browser

Basic HTML structure for integrating the Dropzone library to handle video uploads.

```html
<!DOCTYPE html>  
<html>  
  <head>  
    <meta charset="utf-8" />  
    <meta name="viewport" content="width=device-width" />  
    <title>Sample dropzone upload</title>  
    <link rel="stylesheet"  
          href="https://cdnjs.cloudflare.com/ajax/libs/dropzone/5.9.3/dropzone.min.css">  
  </head>  
  <body>  
    <div id="myId" class="dropbox">Upload videos</div>  
    <script src="https://cdnjs.cloudflare.com/ajax/libs/dropzone/5.9.3/dropzone.min.js"></script>  
    <script src="./myapp.js"></script>  
  </body>  
</html>
```

--------------------------------

### Get OTP with Whitelist Parameter

Source: https://www.vdocipher.com/docs/server/playbackauth/whitelist

Examples of requesting an OTP with a whitelisted hostname across various programming languages.

```curl
curl -X POST \
  https://dev.vdocipher.com/api/videos/1234567890/otp \
  -H 'Accept: application/json' \
  -H 'Authorization: Apisecret a1b2c3d4e5' \
  -H 'Content-Type: application/json' \
  -d '{
  "whitelisthref":"vdocipher.com"
}'
```

```javascript
var request = require('request');

var options = {
  method: 'POST',
  url: 'https://dev.vdocipher.com/api/videos/1234567890/otp',
  headers: {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
    'Authorization': 'Apisecret a1b2c3d4e5',
  },
  body: {whitelisthref: 'vdocipher.com'},
  json: true,
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

```php
$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://dev.vdocipher.com/api/videos/1234567890/otp",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    "whitelisthref" => "vdocipher.com"
  ]),
  CURLOPT_HTTPHEADER => array(
    "Accept: application/json",
    "Authorization: Apisecret a1b2c3d4e5",
    "Content-Type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```csharp
var client = new RestClient("https://dev.vdocipher.com/api/videos/1234567890/otp");
var request = new RestRequest(Method.POST);
request.AddHeader("Accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Apisecret a1b2c3d4e5");
request.AddParameter("undefined", "{\n\t\"whitelisthref\":\"vdocipher.com\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```python
import requests
import json

url = "https://dev.vdocipher.com/api/videos/1234567890/otp"

payload = json.dumps({"whitelisthref":"vdocipher.com"})
headers = {
    'Authorization': "Apisecret a1b2c3d4e5",
    'Content-Type': "application/json",
    'Accept': "application/json",
    }

response = requests.request("POST", url, data=payload, headers=headers)

print(response.text)
```

```ruby
require 'uri'
require 'json'
require 'net/http'

url = URI("https://dev.vdocipher.com/api/videos/1234567890/otp")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Apisecret a1b2c3d4e5'
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request.body = ({:whitelisthref => "vdocipher.com"}).to_json

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

--------------------------------

### Import Video via PHP

Source: https://www.vdocipher.com/docs/server/upload/import-url

Example of initiating a video import using cURL in PHP.

```php
$curl = curl_init();
  
curl_setopt_array($curl, array(
  CURLOPT_URL => "https://dev.vdocipher.com/api/videos/importUrl",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    "url" => "{{URLString}}",
    "folderId" => "{{folderID}}",
    "title" => "{{videoTitle}}"
  ]),
  CURLOPT_HTTPHEADER => array(
    "Accept: application/json",
    "Authorization: Apisecret a1b2c3d4e5",
    "Content-Type: application/json"
  ),
));
  
$response = curl_exec($curl);
$err = curl_error($curl);
  
curl_close($curl);
  
if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

--------------------------------

### Import Video via CURL

Source: https://www.vdocipher.com/docs/server/upload/import-url

Example of initiating a video import using the command line tool cURL.

```bash
curl -X PUT \
  https://dev.vdocipher.com/api/videos/importUrl \
  -H 'Accept: application/json' \
  -H 'Authorization: Apisecret a1b2c3d4e5' \
  -H 'Content-Type: application/json' \
  -d '{
  "url": "{{URLString}}",
  "folderId": "{{folderID}}",
  "title": "{{videoTitle}}"
}'
```

--------------------------------

### Video Search Implementation Examples

Source: https://www.vdocipher.com/docs/server/videomanagement/tags-search

Code examples for performing a tagged video search across various programming languages using the required API secret key.

```curl
curl -X GET \
  'https://dev.vdocipher.com/api/videos?tags={{tag}}' \
  -H 'Accept: application/json' \
  -H 'Authorization: Apisecret a1b2c3d4e5'  

```

```javascript
var request = require('request');  
  
var options = {  
  method: 'GET',  
  url: 'https://dev.vdocipher.com/api/videos',  
  qs: {tags: '{{tag}}'},  
  headers: {  
    Accept: 'application/json',  
    Authorization: 'Apisecret a1b2c3d4e5',  
  },  
};  
  
request(options, function (error, response, body) {  
  if (error) throw new Error(error);  
  
  console.log(body);  
});  

```

```php
$curl = curl_init();  
  
curl_setopt_array($curl, array(  
  CURLOPT_URL => "https://dev.vdocipher.com/api/videos?tags={{tag}}",  
  CURLOPT_RETURNTRANSFER => true,  
  CURLOPT_ENCODING => "",  
  CURLOPT_MAXREDIRS => 10,  
  CURLOPT_TIMEOUT => 30,  
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,  
  CURLOPT_CUSTOMREQUEST => "GET",  
  CURLOPT_HTTPHEADER => array(  
    "Accept: application/json",  
    "Authorization: Apisecret a1b2c3d4e5"  
  ),  
));  
  
$response = curl_exec($curl);  
$err = curl_error($curl);  
  
curl_close($curl);  
  
if ($err) {  
  echo "cURL Error #:" . $err;  
} else {  
  echo $response;  
}  

```

```csharp
var client = new RestClient("https://dev.vdocipher.com/api/videos?tags={{tag}}");  
var request = new RestRequest(Method.GET);  
request.AddHeader("Accept", "application/json");  
request.AddHeader("Authorization", "Apisecret a1b2c3d4e5");  
IRestResponse response = client.Execute(request);  

```

```python
import requests  
  
url = "https://dev.vdocipher.com/api/videos"  
  
querystring = {"tags":"{{tag}}"}  
  
headers = {  
    'Authorization': "Apisecret a1b2c3d4e5",  
    'Accept': "application/json"  
}  
  
response = requests.request("GET", url, headers=headers, params=querystring)  
  
print(response.text)  

```

```ruby
require 'uri'  
require 'net/http'  
  
url = URI("https://dev.vdocipher.com/api/videos?tags={{tag}}")  
  
http = Net::HTTP.new(url.host, url.port)  
http.use_ssl = true  
  
request = Net::HTTP::Get.new(url)  
request["Authorization"] = 'Apisecret a1b2c3d4e5'  
request["Accept"] = 'application/json'  
  
response = http.request(request)  
puts response.read_body  

```

--------------------------------

### List All Webhooks

Source: https://www.vdocipher.com/docs/server/account/hooks

Retrieves a list of all configured webhooks using a GET request.

```bash
curl -i https://dev.vdocipher.com/api/hooks/ -H 'authorization: Apisecret __________' -H 'content-type: application/json'
```

--------------------------------

### Import Video via Node.js

Source: https://www.vdocipher.com/docs/server/upload/import-url

Example of initiating a video import using the request library in Node.js.

```javascript
var request = require('request');
  
var options = {
  method: 'PUT',
  url: 'https://dev.vdocipher.com/api/videos/importUrl',
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    'Authorization': 'Apisecret a1b2c3d4e5',
  },
  body: {
    url: '{{URLString}}',
    folderId: '{{folderID}}',
    title: '{{videoTitle}}',
  },
  json: true,
};
  
request(options, function (error, response, body) {
  if (error) throw new Error(error);
  
  console.log(body);
});
```

--------------------------------

### Import Video via Python

Source: https://www.vdocipher.com/docs/server/upload/import-url

Example of initiating a video import using the requests library in Python.

```python
import requests
import json
  
url = "https://dev.vdocipher.com/api/videos/importUrl"
payload = json.dumps({"url":"{{URLString}}", "folderId": "{{folderID}}","title": "{{videoTitle}}"})
headers = {
  'Authorization': "Apisecret a1b2c3d4e5",
  'Accept': "application/json",
  'Content-Type': "application/json"
}
  
response = requests.request("PUT", url, data=payload, headers=headers)
  
print(response.text)
```

--------------------------------

### Folder search implementation

Source: https://www.vdocipher.com/docs/server/videomanagement/folder-search

Examples of how to perform a folder search using cURL and Node.js.

```bash
curl -X POST "https://dev.vdocipher.com/api/videos/folders/search" \
  -H 'content-type: application/json' \
  -H 'Authorization: Apisecret a1b2c3d4e5' \
  -d "{\"name\": \"__query__\"}"
```

```javascript
var request = require('request');  
  
var options = {  
  method: 'POST',  
  url: 'https://dev.vdocipher.com/api/videos/folders/search',  
  headers: {  
    Authorization: 'Apisecret a1b2c3d4e5',  
  },  
  body: {  
    name: '__query__',  
  },  
  json: true,  
};  
  
request(options, function (error, response, body) {  
  if (error) throw new Error(error);  
  
  console.log(body);  
});
```

--------------------------------

### Sample CURL Request

Source: https://www.vdocipher.com/docs/server/account/video-usage

Example command to fetch bandwidth data for a specific date and save it to a CSV file.

```bash
curl -X POST https://dev.vdocipher.com/api/account/video-usage -H 'authorization: Apisecret _____________________' -d '{"date": "2018-09-05"}' -H 'content-type: application/json' > bandwidth_2018-09-05.csv
```

--------------------------------

### API Response Example

Source: https://www.vdocipher.com/docs/server/videomanagement/folder-create

The JSON object returned by the API upon successful folder creation.

```json
{
  "id": "50d30b04273cxxxxxxxxxxxxxxxxxxxx",
  "parent": null,
  "name": "Sample Folder",
  "videosCount": 0,
  "foldersCount": 0
}
```

--------------------------------

### Import Video via C#

Source: https://www.vdocipher.com/docs/server/upload/import-url

Example of initiating a video import using RestSharp in C#.

```csharp
var client = new RestClient("https://dev.vdocipher.com/api/videos/importUrl");
var request = new RestRequest(Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("Authorization", "Apisecret a1b2c3d4e5");
request.AddParameter("undefined", "{\"url\": \"{{URLString}}\", \"folderId\": \"{{folderID}}\", \"title\": \"{{videoTitle}}\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

--------------------------------

### Initiate Video Playback

Source: https://www.vdocipher.com/docs/mobile/ios/swiftUI

Use the VdoViewManager instance to start playback and handle potential errors.

```swift
viewManager.initiatePlayback { playerView, err in
    if let err = err {
        self.message = err.message
        return
    }
    guard let pView = playerView else {return}
    self.playerView = pView
    self.playerView?.player.play()
}
```

--------------------------------

### Handle Download UI Actions

Source: https://www.vdocipher.com/docs/mobile/ios/sample-controller-file

Logic to handle user interactions for starting, canceling, or deleting video downloads.

```swift
@IBAction func downloadAction(_ sender: Any) {  
        guard let asset = asset, let button = sender as? UIButton, let buttonText = button.currentTitle else {  
            return print("not ready for playback or action not defined")  
        }  
        print("title is \(String(describing: button.currentTitle))")  
        print("download action \(buttonText)")  
        switch buttonText {  
        case "Delete":  
            print("downloaded, now can delete")  
            asset.deleteDownload()  
        case "Cancel":  
            print("downloading..., now can cancel")  
            asset.cancelDownload()  
        case "Download":  
            print("download action triggered")  
            asset.startDownload(otp: otp, playbackInfo: playbackInfo)  
        default:  
            print("can't get here")  
        }  
  
    }
```

--------------------------------

### Obtain credentials via API

Source: https://www.vdocipher.com/docs/server/upload/credentials

Examples of how to request upload credentials using various programming languages.

```bash
curl -X PUT \
  'https://dev.vdocipher.com/api/videos?title=title&folderId=ca038407e1b0XXXXXXXXXXXXXXXXXXXX' \
  -H 'Authorization: Apisecret a1b2c3d4e5'
```

```javascript
var request = require('request');

var options = {
  method: 'PUT',
  url: 'https://dev.vdocipher.com/api/videos',
  qs: {title: 'title', folderId: 'ca038407e1b0xxxxxxxxxxxxxxxxxxxx'},
  headers: {Authorization: 'Apisecret a1b2c3d4e5'},
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

```php
$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://dev.vdocipher.com/api/videos?title=title&folderId=ca038407e1b0XXXXXXXXXXXXXXXXXXXX",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => array(
    "Authorization: Apisecret a1b2c3d4e5"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```csharp
var client = new RestClient("https://dev.vdocipher.com/api/videos?title=title&folderId=ca038407e1b0XXXXXXXXXXXXXXXXXXXX");
var request = new RestRequest(Method.PUT);
request.AddHeader("Authorization", "Apisecret a1b2c3d4e5");
IRestResponse response = client.Execute(request);
```

```python
import requests

url = "https://dev.vdocipher.com/api/videos"

querystring = {"title":"title", "folderId": "ca038407e1b0xxxxxxxxxxxxxxxxxxxx"}

headers = {
    'Authorization': "Apisecret a1b2c3d4e5"
    }

response = requests.request("PUT", url, headers=headers, params=querystring)

print(response.text)
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://dev.vdocipher.com/api/videos?title=title&folderId=ca038407e1b0XXXXXXXXXXXXXXXXXXXX")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["Authorization"] = 'Apisecret a1b2c3d4e5'

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

--------------------------------

### Complete integration sample

Source: https://www.vdocipher.com/docs/player/v2/api-reference/accessing-player

A full example demonstrating the iframe embed, script inclusion, player initialization, and custom API usage.

```html
<html>  
  <body>  
    <iframe  
      src="https://player.vdocipher.com/v2/?otp=[[REPLACE_WITH_OTP]]&playbackInfo=[[REPLACE_WITH_PLAYBACKINFO]]&primaryColor=4245EF"  
      frameborder="0"  
      allow="encrypted-media"  
      allowfullscreen  
    ></iframe>  
  
    <script src="https://player.vdocipher.com/v2/api.js"></script>  
    <script>  
      const iframe = document.querySelector('iframe');  
      // Creating player instance  
      const player = VdoPlayer.getInstance(iframe);  
  
      // All DOM API supports on player.video  
      player.video.addEventListener('play', function () {  
        console.log('Video is playing');  
      });  
  
      // VdoCipher Custom API  
      player.api.getTotalPlayed().then(function (data) {  
        console.log('Video playback: ', data);  
      });  
    </script>  
  </body>  
</html>
```

--------------------------------

### Rename Folder Implementation

Source: https://www.vdocipher.com/docs/server/videomanagement/folder-update

Examples of how to perform the folder rename operation using various programming languages and libraries.

```bash
curl -X PUT \
  https://dev.vdocipher.com/api/videos/folders/{{folderID}} \
  -H 'Accept: application/json' \
  -H 'Authorization: Apisecret a1b2c3d4e5' \
  -H 'Content-Type: application/json' \
  -d '{
  "name": "{{newFolderName}}"
}'
```

```javascript
var request = require('request');

var options = {
  method: 'PUT',
  url: 'https://dev.vdocipher.com/api/videos/folders/{{folderID}}',
  headers: {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
    'Authorization': 'Apisecret a1b2c3d4e5',
  },
  body: {name: '{{newFolderName}}'},
  json: true,
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

```php
$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://dev.vdocipher.com/api/videos/folders/{{folderID}}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    "name" => "{{newFolderName}}"
  ]),
  CURLOPT_HTTPHEADER => array(
    "Accept: application/json",
    "Authorization: Apisecret a1b2c3d4e5",
    "Content-Type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```csharp
var client = new RestClient("https://dev.vdocipher.com/api/videos/folders/{{folderID}}");
var request = new RestRequest(Method.PUT);
request.AddHeader("Accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Apisecret a1b2c3d4e5");
request.AddParameter("undefined", "{\"name\": \"{{newfolderName}}\"}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```python
import requests

url = "https://dev.vdocipher.com/api/videos/folders/{{folderID}}"
payload = json.dumps({
  "name": "{{newFolderName}}"
})
headers = {
  'Authorization': "Apisecret a1b2c3d4e5",
  'Content-Type': "application/json",
  'Accept': "application/json",
}

response = requests.request("PUT", url, headers=headers)

print(response.text)
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://dev.vdocipher.com/api/videos/folders/{{folderID}}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["Authorization"] = 'Apisecret a1b2c3d4e5'
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request.body = ({
  :name => "{{newFolderName}}"
}).to_json

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

--------------------------------

### playOnline(otp:playbackInfo:defaultVideoQuality:playerOptions:)

Source: https://www.vdocipher.com/docs/mobile/ios/api-reference

Starts online playback of the asset using OTP and playback information.

```APIDOC
## playOnline(otp:playbackInfo:defaultVideoQuality:playerOptions:)

### Description
Initiates streaming playback for the asset using authentication credentials.

### Parameters
- **otp** (String) - The one-time password for authentication.
- **playbackInfo** (String) - The playback information string.
- **defaultVideoQuality** (VideoQuality?) - Optional preferred video quality.
- **playerOptions** (PlayerOptions?) - Optional configuration for the player.
```

--------------------------------

### Get OTP with IP Geo-blocking

Source: https://www.vdocipher.com/docs/server/playbackauth/ipgeo

Examples of sending a POST request to the OTP endpoint with IP geo-blocking configuration.

```bash
curl -X POST \
  https://dev.vdocipher.com/api/videos/1234567890/otp \
  -H 'Accept: application/json' \
  -H 'Authorization: Apisecret a1b2c3d4e5' \
  -H 'Content-Type: application/json' \
  -d '{
  "ipGeo": {"allow": ["312.312.312.312"]}
}'
```

```javascript
var request = require('request');

var options = {
  method: 'POST',
  url: 'https://dev.vdocipher.com/api/videos/1234567890/otp',
  headers: {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
    'Authorization': 'Apisecret a1b2c3d4e5',
  },
  body: {
    ipGeo: {allow: ['312.312.312.312']},
  },
  json: true,
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

```php
$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://dev.vdocipher.com/api/videos/1234567890/otp",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ipGeo' => ['allow' => ['312.312.312.312']]
  ]),
  CURLOPT_HTTPHEADER => array(
    "Accept: application/json",
    "Authorization: Apisecret a1b2c3d4e5",
    "Content-Type: application/json"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```csharp
var client = new RestClient("https://dev.vdocipher.com/api/videos/1234567890/otp");
var request = new RestRequest(Method.POST);
request.AddHeader("Accept", "application/json");
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Apisecret a1b2c3d4e5");
request.AddParameter("undefined", "{\n\t\"ipGeo\": {\"allow\": [\"312.312.312.312\"]}\n}",
ParameterType.
RequestBody);
IRestResponse response = client.Execute(request);
```

```python
import requests
import json

url = "https://dev.vdocipher.com/api/videos/1234567890/otp"

payload = json.dumps({
  "ipGeo": {'allow': ['312.312.312.312']}
  })
headers = {
    'Authorization': "Apisecret a1b2c3d4e5",
    'Content-Type': "application/json",
    'Accept': "application/json"
    }

response = requests.request("POST", url, data=payload, headers=headers)

print(response.text)
```

```ruby
require 'uri'
require 'json'
require 'net/http'

url = URI("https://dev.vdocipher.com/api/videos/1234567890/otp")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Apisecret a1b2c3d4e5'
request["Content-Type"] = 'application/json'
request["Accept"] = 'application/json'
request.body = {
  :ipGeo => {'allow': ['312.312.312.312']}
}.to_json

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

--------------------------------

### startDownload(otp:playbackInfo:videoQuality:)

Source: https://www.vdocipher.com/docs/mobile/ios/api-reference

Initiates a download task for the asset.

```APIDOC
## startDownload(otp:playbackInfo:videoQuality:)

### Description
Starts downloading the video asset for offline viewing.

### Parameters
- **otp** (String) - The one-time password for authentication.
- **playbackInfo** (String) - The playback information string.
- **videoQuality** (VideoQuality?) - Optional quality setting for the download.
```

--------------------------------

### Implement Initialization Listener

Source: https://www.vdocipher.com/docs/mobile/android/jetpack-compose

Define the PlayerHost.InitializationListener to handle successful player setup and load media using VdoInitParams.

```kotlin
val initializationListener = object : PlayerHost.InitializationListener {  
        override fun onInitializationSuccess(playerHost: PlayerHost, vdoPlayer: VdoPlayer, wasRestored: Boolean) {  
            // Build a video initialization params object to load the player with a video  
            val vdoInitParams = VdoInitParams.Builder()  
                .setOtp("REPLACE WITH YOUR OTP")  
                .setPlaybackInfo("REPLACE WITH YOUR PLAYBACK INFO")  
                .build()  
  
            // Load the player with the VdoInitParams object  
            vdoPlayer.load(vdoInitParams)  
        }  
  
        override fun onInitializationFailure(playerHost: PlayerHost, errorDescription: ErrorDescription) {  
            // Handle player initialization failure  
        }  
  
        override fun onDeInitializationSuccess() {  
            // Called when the vdoPlayerUIFragment is detached from the parent activity and the player is deinitialized.  
        }  
  
}  
```

--------------------------------

### Complete ContentView Implementation

Source: https://www.vdocipher.com/docs/mobile/ios/swiftUI

A full example demonstrating VdoViewManager integration, playback control, and download state handling in a SwiftUI view.

```swift
import SwiftUI
import VdoFramework

struct ContentView: View {
    @ObservedObject var item: VdoViewManager = VdoViewManager.init(
        videoId: "0eb55d5dc2264f80b19c0c24bffabfe3",
        otp: "20160313versIND313dgKrFOzMsDcQQxb85m3eMUGhATPIqHcGbBkVOmWsaX6jF1",
        playbackInfo: "eyJ2aWRlb0lkIjoiMGViNTVkNWRjMjI2NGY4MGIxOWMwYzI0YmZmYWJmZTMifQ==")
    @State var message: String = ""
    @State var playerView: PlayerView?
    var body: some View {
        VStack {
            playerView
            Button("Play") {
                item.initiatePlayback { playerView, err in
                    if let err = err {
                        self.message = err.message
                        return
                    }
                    guard let pView = playerView else {return}
                    self.playerView = pView
                    self.playerView?.player.play()
                }
            }.buttonStyle(.borderless).padding()
            Text(message)
            switch item.downloadState {
            case .downloaded:
                do {
                    Button("Delete Download") {
                        item.deleteDownload()
                    }.buttonStyle(.borderless).padding()
                }
            case .notDownloaded:
                do {
                    Button("Download") {
                        item.initiateDownload()
                    }.buttonStyle(.borderless).padding()
                }
            case .downloading:
                do {
                    Button("Cancel Download") {
                        item.cancelDownload()
                    }.buttonStyle(.borderless).padding()
                }
            case .none:
                do {

                }
            @unknown default:
                fatalError("Failed to identify download state of video \(item.id)")
            }
        }
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}
```

--------------------------------

### List Sub-folders API Request

Source: https://www.vdocipher.com/docs/server/videomanagement/folder-list

Examples of how to perform an HTTP GET request to list sub-folders. Replace :folderId with the target folder ID and use 'root' for the root folder.

```bash
curl -X GET \
  https://dev.vdocipher.com/api/videos/folders/:folderId \
  -H 'Accept: application/json' \
  -H 'Authorization: Apisecret a1b2c3d4e5'
```

```javascript
var request = require('request');

var options = {
  method: 'GET',
  url: 'https://dev.vdocipher.com/api/videos/folders/:folderId',
  headers: {
    Accept: 'application/json',
    Authorization: 'Apisecret a1b2c3d4e5',
  },
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
```

```php
$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://dev.vdocipher.com/api/videos/folders/:folderId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => array(
    "Accept: application/json",
    "Authorization: Apisecret a1b2c3d4e5"
  ),
));

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```csharp
var client = new RestClient("https://dev.vdocipher.com/api/videos/folders/:folderId");
var request = new RestRequest(Method.GET);
request.AddHeader("Accept", "application/json");
request.AddHeader("Authorization", "Apisecret a1b2c3d4e5");
IRestResponse response = client.Execute(request);
```

```python
import requests

url = "https://dev.vdocipher.com/api/videos/folders/:folderId"

headers = {
  'Authorization': "Apisecret a1b2c3d4e5",
  'Accept': "application/json",
}

response = requests.request("GET", url, headers=headers)

print(response.text)
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://dev.vdocipher.com/api/videos/folders/:folderId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Apisecret a1b2c3d4e5'
request["Accept"] = 'application/json'

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

--------------------------------

### GET /policy

Source: https://www.vdocipher.com/docs/swagger/index.html

Get a list of license policies.

```APIDOC
## GET /policy

### Description
Get list of policies

### Method
GET

### Endpoint
/policy
```

--------------------------------

### GET /videos/{videoId}

Source: https://www.vdocipher.com/docs/swagger/index.html

Get detailed information about a specific video.

```APIDOC
## GET /videos/{videoId}

### Description
Get detailed information about a video.

### Method
GET

### Endpoint
/videos/{videoId}

### Parameters
#### Path Parameters
- **videoId** (string) - Required - The unique identifier of the video.
```

--------------------------------

### startVideoScreen(embedInfo, enablePiP)

Source: https://www.vdocipher.com/docs/mobile/react-native/getting-started

Launches the video in a fullscreen player. The second parameter is an optional boolean to enable picture-in-picture support.

```APIDOC
## startVideoScreen(embedInfo, enablePiP)

### Description
Launches the video in a fullscreen player. Optionally enables picture-in-picture mode.

### Parameters
- **embedInfo** (object) - Required - Contains {otp: string, playbackInfo: string}
- **enablePiP** (boolean) - Optional - Set to true to enable picture-in-picture support

### Example
```javascript
import {startVideoScreen} from 'vdocipher-rn-bridge';

startVideoScreen(
  {embedInfo: {otp: 'some-otp', playbackInfo: 'some-playbackInfo'}},
  true
);
```

--------------------------------

### GET /videos/{videoId}/files

Source: https://www.vdocipher.com/docs/swagger/index.html

Get a list of files and their properties for a video.

```APIDOC
## GET /videos/{videoId}/files

### Description
Get list of files and their properties

### Method
GET

### Endpoint
/videos/{videoId}/files

### Parameters
#### Path Parameters
- **videoId** (string) - Required - The unique identifier of the video.
```

--------------------------------

### Initialize PlayerOptions

Source: https://www.vdocipher.com/docs/mobile/ios/api-reference

Configures player options, optionally including a clipping model.

```swift
init(clippingModelConfig: VdoFramework.Clipping? = nil)
```
Tokens:
Raw