Wowza Streaming Cloud REST API Reference Documentation
POST
Create a live stream
{{baseUrl}}/live_streams
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/live_streams")require "http/client"
url = "{{baseUrl}}/live_streams"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/live_streams"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/live_streams HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/live_streams")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/live_streams")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/live_streams');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/live_streams'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/live_streams'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/live_streams');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/live_streams'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/live_streams');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/live_streams")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/live_streams') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/live_streamshttp POST {{baseUrl}}/live_streamswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/live_streamsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a live stream
{{baseUrl}}/live_streams/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/live_streams/:id")require "http/client"
url = "{{baseUrl}}/live_streams/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/live_streams/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/live_streams/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/live_streams/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/live_streams/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/live_streams/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'DELETE', url: '{{baseUrl}}/live_streams/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/live_streams/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'DELETE', url: '{{baseUrl}}/live_streams/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/live_streams/:id');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/live_streams/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/live_streams/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/live_streams/:idhttp DELETE {{baseUrl}}/live_streams/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/live_streams/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a live stream
{{baseUrl}}/live_streams/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/live_streams/:id")require "http/client"
url = "{{baseUrl}}/live_streams/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/live_streams/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/live_streams/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/live_streams/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/live_streams/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/live_streams/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/live_streams/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/live_streams/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/live_streams/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/live_streams/:id');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/live_streams/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/live_streams/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/live_streams/:idhttp GET {{baseUrl}}/live_streams/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/live_streams/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all live streams
{{baseUrl}}/live_streams
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/live_streams")require "http/client"
url = "{{baseUrl}}/live_streams"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/live_streams"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/live_streams HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/live_streams")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/live_streams")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/live_streams');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/live_streams'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/live_streams'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/live_streams');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/live_streams'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/live_streams');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/live_streams")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/live_streams') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/live_streamshttp GET {{baseUrl}}/live_streamswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/live_streamsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch metrics for an active live stream
{{baseUrl}}/live_streams/:id/stats
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id/stats");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/live_streams/:id/stats")require "http/client"
url = "{{baseUrl}}/live_streams/:id/stats"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id/stats"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id/stats");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id/stats"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/live_streams/:id/stats HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/live_streams/:id/stats")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id/stats"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id/stats")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/live_streams/:id/stats")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/live_streams/:id/stats');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/live_streams/:id/stats'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id/stats';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id/stats',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id/stats")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id/stats',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/live_streams/:id/stats'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/live_streams/:id/stats');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/live_streams/:id/stats'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id/stats';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id/stats"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id/stats" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id/stats",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/live_streams/:id/stats');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id/stats');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id/stats');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id/stats' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id/stats' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/live_streams/:id/stats")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id/stats"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id/stats"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id/stats")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/live_streams/:id/stats') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id/stats";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/live_streams/:id/statshttp GET {{baseUrl}}/live_streams/:id/statswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/live_streams/:id/statsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id/stats")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch the state of a live stream
{{baseUrl}}/live_streams/:id/state
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id/state");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/live_streams/:id/state")require "http/client"
url = "{{baseUrl}}/live_streams/:id/state"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id/state"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id/state");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id/state"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/live_streams/:id/state HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/live_streams/:id/state")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id/state"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id/state")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/live_streams/:id/state")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/live_streams/:id/state');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/live_streams/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id/state',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id/state")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id/state',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/live_streams/:id/state'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/live_streams/:id/state');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/live_streams/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id/state"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id/state" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id/state",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/live_streams/:id/state');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id/state');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id/state');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id/state' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id/state' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/live_streams/:id/state")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id/state"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id/state"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id/state")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/live_streams/:id/state') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id/state";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/live_streams/:id/statehttp GET {{baseUrl}}/live_streams/:id/statewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/live_streams/:id/stateimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id/state")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch the thumbnail URL of a live stream
{{baseUrl}}/live_streams/:id/thumbnail_url
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id/thumbnail_url");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/live_streams/:id/thumbnail_url")require "http/client"
url = "{{baseUrl}}/live_streams/:id/thumbnail_url"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id/thumbnail_url"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id/thumbnail_url");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id/thumbnail_url"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/live_streams/:id/thumbnail_url HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/live_streams/:id/thumbnail_url")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id/thumbnail_url"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id/thumbnail_url")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/live_streams/:id/thumbnail_url")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/live_streams/:id/thumbnail_url');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/live_streams/:id/thumbnail_url'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id/thumbnail_url';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id/thumbnail_url',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id/thumbnail_url")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id/thumbnail_url',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/live_streams/:id/thumbnail_url'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/live_streams/:id/thumbnail_url');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/live_streams/:id/thumbnail_url'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id/thumbnail_url';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id/thumbnail_url"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id/thumbnail_url" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id/thumbnail_url",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/live_streams/:id/thumbnail_url');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id/thumbnail_url');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id/thumbnail_url');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id/thumbnail_url' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id/thumbnail_url' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/live_streams/:id/thumbnail_url")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id/thumbnail_url"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id/thumbnail_url"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id/thumbnail_url")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/live_streams/:id/thumbnail_url') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id/thumbnail_url";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/live_streams/:id/thumbnail_urlhttp GET {{baseUrl}}/live_streams/:id/thumbnail_urlwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/live_streams/:id/thumbnail_urlimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id/thumbnail_url")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Regenerate the connection code for a live stream
{{baseUrl}}/live_streams/:id/regenerate_connection_code
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id/regenerate_connection_code");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/live_streams/:id/regenerate_connection_code")require "http/client"
url = "{{baseUrl}}/live_streams/:id/regenerate_connection_code"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id/regenerate_connection_code"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id/regenerate_connection_code");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id/regenerate_connection_code"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/live_streams/:id/regenerate_connection_code HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/live_streams/:id/regenerate_connection_code")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id/regenerate_connection_code"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id/regenerate_connection_code")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/live_streams/:id/regenerate_connection_code")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/live_streams/:id/regenerate_connection_code');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/live_streams/:id/regenerate_connection_code'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id/regenerate_connection_code';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id/regenerate_connection_code',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id/regenerate_connection_code")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id/regenerate_connection_code',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/live_streams/:id/regenerate_connection_code'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/live_streams/:id/regenerate_connection_code');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/live_streams/:id/regenerate_connection_code'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id/regenerate_connection_code';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id/regenerate_connection_code"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id/regenerate_connection_code" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id/regenerate_connection_code",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/live_streams/:id/regenerate_connection_code');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id/regenerate_connection_code');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id/regenerate_connection_code');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id/regenerate_connection_code' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id/regenerate_connection_code' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/live_streams/:id/regenerate_connection_code")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id/regenerate_connection_code"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id/regenerate_connection_code"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id/regenerate_connection_code")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/live_streams/:id/regenerate_connection_code') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id/regenerate_connection_code";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/live_streams/:id/regenerate_connection_codehttp PUT {{baseUrl}}/live_streams/:id/regenerate_connection_codewget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/live_streams/:id/regenerate_connection_codeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id/regenerate_connection_code")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Reset a live stream
{{baseUrl}}/live_streams/:id/reset
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id/reset");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/live_streams/:id/reset")require "http/client"
url = "{{baseUrl}}/live_streams/:id/reset"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id/reset"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id/reset");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id/reset"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/live_streams/:id/reset HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/live_streams/:id/reset")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id/reset"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id/reset")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/live_streams/:id/reset")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/live_streams/:id/reset');
xhr.send(data);import axios from 'axios';
const options = {method: 'PUT', url: '{{baseUrl}}/live_streams/:id/reset'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id/reset';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id/reset',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id/reset")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id/reset',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PUT', url: '{{baseUrl}}/live_streams/:id/reset'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/live_streams/:id/reset');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PUT', url: '{{baseUrl}}/live_streams/:id/reset'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id/reset';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id/reset"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id/reset" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id/reset",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/live_streams/:id/reset');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id/reset');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id/reset');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id/reset' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id/reset' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/live_streams/:id/reset")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id/reset"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id/reset"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id/reset")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/live_streams/:id/reset') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id/reset";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/live_streams/:id/resethttp PUT {{baseUrl}}/live_streams/:id/resetwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/live_streams/:id/resetimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id/reset")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Start a live stream
{{baseUrl}}/live_streams/:id/start
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id/start");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/live_streams/:id/start")require "http/client"
url = "{{baseUrl}}/live_streams/:id/start"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id/start"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id/start");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id/start"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/live_streams/:id/start HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/live_streams/:id/start")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id/start"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id/start")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/live_streams/:id/start")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/live_streams/:id/start');
xhr.send(data);import axios from 'axios';
const options = {method: 'PUT', url: '{{baseUrl}}/live_streams/:id/start'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id/start';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id/start',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id/start")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id/start',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PUT', url: '{{baseUrl}}/live_streams/:id/start'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/live_streams/:id/start');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PUT', url: '{{baseUrl}}/live_streams/:id/start'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id/start';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id/start"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id/start" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id/start",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/live_streams/:id/start');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id/start');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id/start');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id/start' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id/start' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/live_streams/:id/start")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id/start"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id/start"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id/start")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/live_streams/:id/start') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id/start";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/live_streams/:id/starthttp PUT {{baseUrl}}/live_streams/:id/startwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/live_streams/:id/startimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id/start")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Stop a live stream
{{baseUrl}}/live_streams/:id/stop
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id/stop");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/live_streams/:id/stop")require "http/client"
url = "{{baseUrl}}/live_streams/:id/stop"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id/stop"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id/stop");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id/stop"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/live_streams/:id/stop HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/live_streams/:id/stop")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id/stop"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id/stop")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/live_streams/:id/stop")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/live_streams/:id/stop');
xhr.send(data);import axios from 'axios';
const options = {method: 'PUT', url: '{{baseUrl}}/live_streams/:id/stop'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id/stop';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id/stop',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id/stop")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id/stop',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PUT', url: '{{baseUrl}}/live_streams/:id/stop'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/live_streams/:id/stop');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PUT', url: '{{baseUrl}}/live_streams/:id/stop'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id/stop';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id/stop"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id/stop" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id/stop",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/live_streams/:id/stop');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id/stop');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id/stop');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id/stop' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id/stop' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/live_streams/:id/stop")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id/stop"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id/stop"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id/stop")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/live_streams/:id/stop') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id/stop";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/live_streams/:id/stophttp PUT {{baseUrl}}/live_streams/:id/stopwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/live_streams/:id/stopimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id/stop")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update a live stream
{{baseUrl}}/live_streams/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/live_streams/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/live_streams/:id")require "http/client"
url = "{{baseUrl}}/live_streams/:id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/live_streams/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/live_streams/:id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/live_streams/:id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/live_streams/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/live_streams/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/live_streams/:id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/live_streams/:id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/live_streams/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/live_streams/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'PATCH', url: '{{baseUrl}}/live_streams/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/live_streams/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/live_streams/:id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/live_streams/:id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/live_streams/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PATCH', url: '{{baseUrl}}/live_streams/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/live_streams/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PATCH', url: '{{baseUrl}}/live_streams/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/live_streams/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/live_streams/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/live_streams/:id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/live_streams/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/live_streams/:id');
echo $response->getBody();setUrl('{{baseUrl}}/live_streams/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/live_streams/:id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/live_streams/:id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/live_streams/:id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/live_streams/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/live_streams/:id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/live_streams/:id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/live_streams/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/live_streams/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/live_streams/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/live_streams/:idhttp PATCH {{baseUrl}}/live_streams/:idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/live_streams/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/live_streams/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch network usage for all stream sources
{{baseUrl}}/usage/network/stream_sources
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usage/network/stream_sources");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/usage/network/stream_sources")require "http/client"
url = "{{baseUrl}}/usage/network/stream_sources"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/usage/network/stream_sources"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/usage/network/stream_sources");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/usage/network/stream_sources"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/usage/network/stream_sources HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usage/network/stream_sources")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/usage/network/stream_sources"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/usage/network/stream_sources")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/usage/network/stream_sources")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/usage/network/stream_sources');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/usage/network/stream_sources'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/usage/network/stream_sources';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/usage/network/stream_sources',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/usage/network/stream_sources")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/usage/network/stream_sources',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/usage/network/stream_sources'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/usage/network/stream_sources');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/usage/network/stream_sources'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/usage/network/stream_sources';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/usage/network/stream_sources"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/usage/network/stream_sources" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/usage/network/stream_sources",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/usage/network/stream_sources');
echo $response->getBody();setUrl('{{baseUrl}}/usage/network/stream_sources');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/usage/network/stream_sources');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/usage/network/stream_sources' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/usage/network/stream_sources' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/usage/network/stream_sources")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/usage/network/stream_sources"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/usage/network/stream_sources"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/usage/network/stream_sources")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/usage/network/stream_sources') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/usage/network/stream_sources";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/usage/network/stream_sourceshttp GET {{baseUrl}}/usage/network/stream_sourceswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/usage/network/stream_sourcesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usage/network/stream_sources")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch network usage for all stream targets
{{baseUrl}}/usage/network/stream_targets
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usage/network/stream_targets");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/usage/network/stream_targets")require "http/client"
url = "{{baseUrl}}/usage/network/stream_targets"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/usage/network/stream_targets"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/usage/network/stream_targets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/usage/network/stream_targets"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/usage/network/stream_targets HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usage/network/stream_targets")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/usage/network/stream_targets"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/usage/network/stream_targets")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/usage/network/stream_targets")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/usage/network/stream_targets');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/usage/network/stream_targets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/usage/network/stream_targets';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/usage/network/stream_targets',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/usage/network/stream_targets")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/usage/network/stream_targets',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/usage/network/stream_targets'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/usage/network/stream_targets');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/usage/network/stream_targets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/usage/network/stream_targets';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/usage/network/stream_targets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/usage/network/stream_targets" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/usage/network/stream_targets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/usage/network/stream_targets');
echo $response->getBody();setUrl('{{baseUrl}}/usage/network/stream_targets');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/usage/network/stream_targets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/usage/network/stream_targets' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/usage/network/stream_targets' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/usage/network/stream_targets")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/usage/network/stream_targets"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/usage/network/stream_targets"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/usage/network/stream_targets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/usage/network/stream_targets') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/usage/network/stream_targets";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/usage/network/stream_targetshttp GET {{baseUrl}}/usage/network/stream_targetswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/usage/network/stream_targetsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usage/network/stream_targets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch network usage for all transcoders
{{baseUrl}}/usage/network/transcoders
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usage/network/transcoders");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/usage/network/transcoders")require "http/client"
url = "{{baseUrl}}/usage/network/transcoders"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/usage/network/transcoders"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/usage/network/transcoders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/usage/network/transcoders"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/usage/network/transcoders HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usage/network/transcoders")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/usage/network/transcoders"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/usage/network/transcoders")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/usage/network/transcoders")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/usage/network/transcoders');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/usage/network/transcoders'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/usage/network/transcoders';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/usage/network/transcoders',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/usage/network/transcoders")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/usage/network/transcoders',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/usage/network/transcoders'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/usage/network/transcoders');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/usage/network/transcoders'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/usage/network/transcoders';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/usage/network/transcoders"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/usage/network/transcoders" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/usage/network/transcoders",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/usage/network/transcoders');
echo $response->getBody();setUrl('{{baseUrl}}/usage/network/transcoders');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/usage/network/transcoders');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/usage/network/transcoders' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/usage/network/transcoders' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/usage/network/transcoders")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/usage/network/transcoders"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/usage/network/transcoders"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/usage/network/transcoders")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/usage/network/transcoders') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/usage/network/transcoders";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/usage/network/transcodershttp GET {{baseUrl}}/usage/network/transcoderswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/usage/network/transcodersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usage/network/transcoders")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a player URL
{{baseUrl}}/players/:player_id/urls
QUERY PARAMS
player_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players/:player_id/urls");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/players/:player_id/urls")require "http/client"
url = "{{baseUrl}}/players/:player_id/urls"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/players/:player_id/urls"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players/:player_id/urls");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players/:player_id/urls"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/players/:player_id/urls HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/players/:player_id/urls")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players/:player_id/urls"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/players/:player_id/urls")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/players/:player_id/urls');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/players/:player_id/urls'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players/:player_id/urls';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players/:player_id/urls',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/players/:player_id/urls',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/players/:player_id/urls'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/players/:player_id/urls');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/players/:player_id/urls'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players/:player_id/urls';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players/:player_id/urls"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players/:player_id/urls" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players/:player_id/urls",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/players/:player_id/urls');
echo $response->getBody();setUrl('{{baseUrl}}/players/:player_id/urls');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players/:player_id/urls');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players/:player_id/urls' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/players/:player_id/urls' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/players/:player_id/urls")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players/:player_id/urls"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players/:player_id/urls"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players/:player_id/urls")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/players/:player_id/urls') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players/:player_id/urls";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/players/:player_id/urlshttp POST {{baseUrl}}/players/:player_id/urlswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/players/:player_id/urlsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players/:player_id/urls")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a player URL
{{baseUrl}}/players/:player_id/urls/:id
QUERY PARAMS
player_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players/:player_id/urls/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/players/:player_id/urls/:id")require "http/client"
url = "{{baseUrl}}/players/:player_id/urls/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/players/:player_id/urls/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players/:player_id/urls/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players/:player_id/urls/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/players/:player_id/urls/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/players/:player_id/urls/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players/:player_id/urls/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/players/:player_id/urls/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/players/:player_id/urls/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/players/:player_id/urls/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players/:player_id/urls/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players/:player_id/urls/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/players/:player_id/urls/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/players/:player_id/urls/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/players/:player_id/urls/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/players/:player_id/urls/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players/:player_id/urls/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players/:player_id/urls/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players/:player_id/urls/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players/:player_id/urls/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/players/:player_id/urls/:id');
echo $response->getBody();setUrl('{{baseUrl}}/players/:player_id/urls/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players/:player_id/urls/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players/:player_id/urls/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/players/:player_id/urls/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/players/:player_id/urls/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players/:player_id/urls/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players/:player_id/urls/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players/:player_id/urls/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/players/:player_id/urls/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players/:player_id/urls/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/players/:player_id/urls/:idhttp DELETE {{baseUrl}}/players/:player_id/urls/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/players/:player_id/urls/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players/:player_id/urls/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a player URL
{{baseUrl}}/players/:player_id/urls/:id
QUERY PARAMS
player_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players/:player_id/urls/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/players/:player_id/urls/:id")require "http/client"
url = "{{baseUrl}}/players/:player_id/urls/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/players/:player_id/urls/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players/:player_id/urls/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players/:player_id/urls/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/players/:player_id/urls/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/players/:player_id/urls/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players/:player_id/urls/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/players/:player_id/urls/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/players/:player_id/urls/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/players/:player_id/urls/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players/:player_id/urls/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players/:player_id/urls/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/players/:player_id/urls/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/players/:player_id/urls/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/players/:player_id/urls/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/players/:player_id/urls/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players/:player_id/urls/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players/:player_id/urls/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players/:player_id/urls/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players/:player_id/urls/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/players/:player_id/urls/:id');
echo $response->getBody();setUrl('{{baseUrl}}/players/:player_id/urls/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players/:player_id/urls/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players/:player_id/urls/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/players/:player_id/urls/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/players/:player_id/urls/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players/:player_id/urls/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players/:player_id/urls/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players/:player_id/urls/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/players/:player_id/urls/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players/:player_id/urls/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/players/:player_id/urls/:idhttp GET {{baseUrl}}/players/:player_id/urls/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/players/:player_id/urls/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players/:player_id/urls/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a player
{{baseUrl}}/players/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/players/:id")require "http/client"
url = "{{baseUrl}}/players/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/players/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/players/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/players/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/players/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/players/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/players/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/players/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/players/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/players/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/players/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/players/:id');
echo $response->getBody();setUrl('{{baseUrl}}/players/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/players/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/players/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/players/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/players/:idhttp GET {{baseUrl}}/players/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/players/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all player URLs
{{baseUrl}}/players/:player_id/urls
QUERY PARAMS
player_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players/:player_id/urls");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/players/:player_id/urls")require "http/client"
url = "{{baseUrl}}/players/:player_id/urls"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/players/:player_id/urls"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players/:player_id/urls");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players/:player_id/urls"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/players/:player_id/urls HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/players/:player_id/urls")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players/:player_id/urls"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/players/:player_id/urls")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/players/:player_id/urls');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/players/:player_id/urls'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players/:player_id/urls';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players/:player_id/urls',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/players/:player_id/urls',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/players/:player_id/urls'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/players/:player_id/urls');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/players/:player_id/urls'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players/:player_id/urls';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players/:player_id/urls"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players/:player_id/urls" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players/:player_id/urls",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/players/:player_id/urls');
echo $response->getBody();setUrl('{{baseUrl}}/players/:player_id/urls');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players/:player_id/urls');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players/:player_id/urls' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/players/:player_id/urls' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/players/:player_id/urls")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players/:player_id/urls"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players/:player_id/urls"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players/:player_id/urls")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/players/:player_id/urls') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players/:player_id/urls";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/players/:player_id/urlshttp GET {{baseUrl}}/players/:player_id/urlswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/players/:player_id/urlsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players/:player_id/urls")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all players
{{baseUrl}}/players
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/players")require "http/client"
url = "{{baseUrl}}/players"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/players"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/players HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/players")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/players")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/players');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/players'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/players',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/players'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/players');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/players'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/players');
echo $response->getBody();setUrl('{{baseUrl}}/players');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/players' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/players")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/players') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/playershttp GET {{baseUrl}}/playerswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/playersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch the state of a player
{{baseUrl}}/players/:id/state
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players/:id/state");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/players/:id/state")require "http/client"
url = "{{baseUrl}}/players/:id/state"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/players/:id/state"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players/:id/state");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players/:id/state"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/players/:id/state HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/players/:id/state")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players/:id/state"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players/:id/state")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/players/:id/state")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/players/:id/state');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/players/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players/:id/state',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players/:id/state")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/players/:id/state',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/players/:id/state'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/players/:id/state');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/players/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players/:id/state"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players/:id/state" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players/:id/state",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/players/:id/state');
echo $response->getBody();setUrl('{{baseUrl}}/players/:id/state');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players/:id/state');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players/:id/state' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/players/:id/state' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/players/:id/state")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players/:id/state"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players/:id/state"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players/:id/state")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/players/:id/state') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players/:id/state";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/players/:id/statehttp GET {{baseUrl}}/players/:id/statewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/players/:id/stateimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players/:id/state")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Rebuild player code
{{baseUrl}}/players/:id/rebuild
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players/:id/rebuild");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/players/:id/rebuild")require "http/client"
url = "{{baseUrl}}/players/:id/rebuild"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/players/:id/rebuild"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players/:id/rebuild");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players/:id/rebuild"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/players/:id/rebuild HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/players/:id/rebuild")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players/:id/rebuild"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players/:id/rebuild")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/players/:id/rebuild")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/players/:id/rebuild');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/players/:id/rebuild'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players/:id/rebuild';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players/:id/rebuild',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players/:id/rebuild")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/players/:id/rebuild',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/players/:id/rebuild'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/players/:id/rebuild');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/players/:id/rebuild'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players/:id/rebuild';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players/:id/rebuild"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players/:id/rebuild" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players/:id/rebuild",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/players/:id/rebuild');
echo $response->getBody();setUrl('{{baseUrl}}/players/:id/rebuild');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players/:id/rebuild');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players/:id/rebuild' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/players/:id/rebuild' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/players/:id/rebuild")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players/:id/rebuild"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players/:id/rebuild"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players/:id/rebuild")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/players/:id/rebuild') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players/:id/rebuild";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/players/:id/rebuildhttp POST {{baseUrl}}/players/:id/rebuildwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/players/:id/rebuildimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players/:id/rebuild")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update a player URL
{{baseUrl}}/players/:player_id/urls/:id
QUERY PARAMS
player_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players/:player_id/urls/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/players/:player_id/urls/:id")require "http/client"
url = "{{baseUrl}}/players/:player_id/urls/:id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/players/:player_id/urls/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players/:player_id/urls/:id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players/:player_id/urls/:id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/players/:player_id/urls/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/players/:player_id/urls/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players/:player_id/urls/:id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls/:id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/players/:player_id/urls/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/players/:player_id/urls/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/players/:player_id/urls/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players/:player_id/urls/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players/:player_id/urls/:id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players/:player_id/urls/:id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/players/:player_id/urls/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/players/:player_id/urls/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/players/:player_id/urls/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/players/:player_id/urls/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players/:player_id/urls/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players/:player_id/urls/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players/:player_id/urls/:id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players/:player_id/urls/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/players/:player_id/urls/:id');
echo $response->getBody();setUrl('{{baseUrl}}/players/:player_id/urls/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players/:player_id/urls/:id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players/:player_id/urls/:id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/players/:player_id/urls/:id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/players/:player_id/urls/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players/:player_id/urls/:id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players/:player_id/urls/:id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players/:player_id/urls/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/players/:player_id/urls/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players/:player_id/urls/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/players/:player_id/urls/:idhttp PATCH {{baseUrl}}/players/:player_id/urls/:idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/players/:player_id/urls/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players/:player_id/urls/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update a player
{{baseUrl}}/players/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/players/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/players/:id")require "http/client"
url = "{{baseUrl}}/players/:id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/players/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/players/:id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/players/:id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/players/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/players/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/players/:id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/players/:id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/players/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/players/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'PATCH', url: '{{baseUrl}}/players/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/players/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/players/:id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/players/:id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/players/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PATCH', url: '{{baseUrl}}/players/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/players/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PATCH', url: '{{baseUrl}}/players/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/players/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/players/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/players/:id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/players/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/players/:id');
echo $response->getBody();setUrl('{{baseUrl}}/players/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/players/:id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/players/:id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/players/:id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/players/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/players/:id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/players/:id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/players/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/players/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/players/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/players/:idhttp PATCH {{baseUrl}}/players/:idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/players/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/players/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch stream processing time
{{baseUrl}}/usage/time/transcoders
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usage/time/transcoders");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/usage/time/transcoders")require "http/client"
url = "{{baseUrl}}/usage/time/transcoders"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/usage/time/transcoders"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/usage/time/transcoders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/usage/time/transcoders"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/usage/time/transcoders HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usage/time/transcoders")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/usage/time/transcoders"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/usage/time/transcoders")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/usage/time/transcoders")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/usage/time/transcoders');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/usage/time/transcoders'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/usage/time/transcoders';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/usage/time/transcoders',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/usage/time/transcoders")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/usage/time/transcoders',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/usage/time/transcoders'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/usage/time/transcoders');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/usage/time/transcoders'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/usage/time/transcoders';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/usage/time/transcoders"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/usage/time/transcoders" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/usage/time/transcoders",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/usage/time/transcoders');
echo $response->getBody();setUrl('{{baseUrl}}/usage/time/transcoders');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/usage/time/transcoders');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/usage/time/transcoders' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/usage/time/transcoders' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/usage/time/transcoders")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/usage/time/transcoders"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/usage/time/transcoders"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/usage/time/transcoders")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/usage/time/transcoders') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/usage/time/transcoders";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/usage/time/transcodershttp GET {{baseUrl}}/usage/time/transcoderswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/usage/time/transcodersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usage/time/transcoders")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a recording
{{baseUrl}}/recordings/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/recordings/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/recordings/:id")require "http/client"
url = "{{baseUrl}}/recordings/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/recordings/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/recordings/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/recordings/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/recordings/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/recordings/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/recordings/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/recordings/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/recordings/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/recordings/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/recordings/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/recordings/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/recordings/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/recordings/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/recordings/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'DELETE', url: '{{baseUrl}}/recordings/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/recordings/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'DELETE', url: '{{baseUrl}}/recordings/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/recordings/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/recordings/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/recordings/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/recordings/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/recordings/:id');
echo $response->getBody();setUrl('{{baseUrl}}/recordings/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/recordings/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/recordings/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/recordings/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/recordings/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/recordings/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/recordings/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/recordings/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/recordings/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/recordings/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/recordings/:idhttp DELETE {{baseUrl}}/recordings/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/recordings/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/recordings/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a recording
{{baseUrl}}/recordings/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/recordings/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/recordings/:id")require "http/client"
url = "{{baseUrl}}/recordings/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/recordings/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/recordings/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/recordings/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/recordings/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/recordings/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/recordings/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/recordings/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/recordings/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/recordings/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/recordings/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/recordings/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/recordings/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/recordings/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/recordings/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/recordings/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/recordings/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/recordings/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/recordings/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/recordings/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/recordings/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/recordings/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/recordings/:id');
echo $response->getBody();setUrl('{{baseUrl}}/recordings/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/recordings/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/recordings/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/recordings/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/recordings/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/recordings/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/recordings/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/recordings/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/recordings/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/recordings/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/recordings/:idhttp GET {{baseUrl}}/recordings/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/recordings/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/recordings/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all recordings
{{baseUrl}}/recordings
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/recordings");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/recordings")require "http/client"
url = "{{baseUrl}}/recordings"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/recordings"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/recordings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/recordings"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/recordings HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/recordings")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/recordings"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/recordings")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/recordings")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/recordings');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/recordings'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/recordings';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/recordings',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/recordings")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/recordings',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/recordings'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/recordings');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/recordings'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/recordings';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/recordings"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/recordings" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/recordings",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/recordings');
echo $response->getBody();setUrl('{{baseUrl}}/recordings');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/recordings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/recordings' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/recordings' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/recordings")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/recordings"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/recordings"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/recordings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/recordings') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/recordings";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/recordingshttp GET {{baseUrl}}/recordingswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/recordingsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/recordings")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch the state of a recording
{{baseUrl}}/recordings/:id/state
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/recordings/:id/state");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/recordings/:id/state")require "http/client"
url = "{{baseUrl}}/recordings/:id/state"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/recordings/:id/state"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/recordings/:id/state");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/recordings/:id/state"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/recordings/:id/state HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/recordings/:id/state")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/recordings/:id/state"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/recordings/:id/state")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/recordings/:id/state")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/recordings/:id/state');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/recordings/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/recordings/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/recordings/:id/state',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/recordings/:id/state")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/recordings/:id/state',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/recordings/:id/state'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/recordings/:id/state');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/recordings/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/recordings/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/recordings/:id/state"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/recordings/:id/state" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/recordings/:id/state",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/recordings/:id/state');
echo $response->getBody();setUrl('{{baseUrl}}/recordings/:id/state');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/recordings/:id/state');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/recordings/:id/state' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/recordings/:id/state' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/recordings/:id/state")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/recordings/:id/state"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/recordings/:id/state"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/recordings/:id/state")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/recordings/:id/state') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/recordings/:id/state";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/recordings/:id/statehttp GET {{baseUrl}}/recordings/:id/statewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/recordings/:id/stateimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/recordings/:id/state")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a schedule
{{baseUrl}}/schedules
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/schedules");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/schedules")require "http/client"
url = "{{baseUrl}}/schedules"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/schedules"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/schedules");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/schedules"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/schedules HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/schedules")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/schedules"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/schedules")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/schedules")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/schedules');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/schedules'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/schedules';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/schedules',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/schedules")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/schedules',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/schedules'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/schedules');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/schedules'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/schedules';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/schedules"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/schedules" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/schedules",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/schedules');
echo $response->getBody();setUrl('{{baseUrl}}/schedules');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/schedules');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/schedules' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/schedules' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/schedules")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/schedules"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/schedules"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/schedules")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/schedules') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/schedules";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/scheduleshttp POST {{baseUrl}}/scheduleswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/schedulesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/schedules")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a schedule
{{baseUrl}}/schedules/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/schedules/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/schedules/:id")require "http/client"
url = "{{baseUrl}}/schedules/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/schedules/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/schedules/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/schedules/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/schedules/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/schedules/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/schedules/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/schedules/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/schedules/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/schedules/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/schedules/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/schedules/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/schedules/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/schedules/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/schedules/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'DELETE', url: '{{baseUrl}}/schedules/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/schedules/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'DELETE', url: '{{baseUrl}}/schedules/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/schedules/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/schedules/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/schedules/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/schedules/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/schedules/:id');
echo $response->getBody();setUrl('{{baseUrl}}/schedules/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/schedules/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/schedules/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/schedules/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/schedules/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/schedules/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/schedules/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/schedules/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/schedules/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/schedules/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/schedules/:idhttp DELETE {{baseUrl}}/schedules/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/schedules/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/schedules/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Disable a schedule
{{baseUrl}}/schedules/:id/disable
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/schedules/:id/disable");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/schedules/:id/disable")require "http/client"
url = "{{baseUrl}}/schedules/:id/disable"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/schedules/:id/disable"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/schedules/:id/disable");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/schedules/:id/disable"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/schedules/:id/disable HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/schedules/:id/disable")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/schedules/:id/disable"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/schedules/:id/disable")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/schedules/:id/disable")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/schedules/:id/disable');
xhr.send(data);import axios from 'axios';
const options = {method: 'PUT', url: '{{baseUrl}}/schedules/:id/disable'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/schedules/:id/disable';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/schedules/:id/disable',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/schedules/:id/disable")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/schedules/:id/disable',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PUT', url: '{{baseUrl}}/schedules/:id/disable'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/schedules/:id/disable');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PUT', url: '{{baseUrl}}/schedules/:id/disable'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/schedules/:id/disable';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/schedules/:id/disable"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/schedules/:id/disable" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/schedules/:id/disable",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/schedules/:id/disable');
echo $response->getBody();setUrl('{{baseUrl}}/schedules/:id/disable');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/schedules/:id/disable');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/schedules/:id/disable' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/schedules/:id/disable' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/schedules/:id/disable")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/schedules/:id/disable"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/schedules/:id/disable"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/schedules/:id/disable")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/schedules/:id/disable') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/schedules/:id/disable";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/schedules/:id/disablehttp PUT {{baseUrl}}/schedules/:id/disablewget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/schedules/:id/disableimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/schedules/:id/disable")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Enable a schedule
{{baseUrl}}/schedules/:id/enable
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/schedules/:id/enable");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/schedules/:id/enable")require "http/client"
url = "{{baseUrl}}/schedules/:id/enable"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/schedules/:id/enable"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/schedules/:id/enable");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/schedules/:id/enable"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/schedules/:id/enable HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/schedules/:id/enable")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/schedules/:id/enable"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/schedules/:id/enable")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/schedules/:id/enable")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/schedules/:id/enable');
xhr.send(data);import axios from 'axios';
const options = {method: 'PUT', url: '{{baseUrl}}/schedules/:id/enable'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/schedules/:id/enable';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/schedules/:id/enable',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/schedules/:id/enable")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/schedules/:id/enable',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PUT', url: '{{baseUrl}}/schedules/:id/enable'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/schedules/:id/enable');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PUT', url: '{{baseUrl}}/schedules/:id/enable'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/schedules/:id/enable';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/schedules/:id/enable"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/schedules/:id/enable" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/schedules/:id/enable",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/schedules/:id/enable');
echo $response->getBody();setUrl('{{baseUrl}}/schedules/:id/enable');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/schedules/:id/enable');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/schedules/:id/enable' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/schedules/:id/enable' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/schedules/:id/enable")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/schedules/:id/enable"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/schedules/:id/enable"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/schedules/:id/enable")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/schedules/:id/enable') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/schedules/:id/enable";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/schedules/:id/enablehttp PUT {{baseUrl}}/schedules/:id/enablewget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/schedules/:id/enableimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/schedules/:id/enable")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a schedule
{{baseUrl}}/schedules/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/schedules/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/schedules/:id")require "http/client"
url = "{{baseUrl}}/schedules/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/schedules/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/schedules/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/schedules/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/schedules/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/schedules/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/schedules/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/schedules/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/schedules/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/schedules/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/schedules/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/schedules/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/schedules/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/schedules/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/schedules/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/schedules/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/schedules/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/schedules/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/schedules/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/schedules/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/schedules/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/schedules/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/schedules/:id');
echo $response->getBody();setUrl('{{baseUrl}}/schedules/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/schedules/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/schedules/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/schedules/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/schedules/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/schedules/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/schedules/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/schedules/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/schedules/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/schedules/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/schedules/:idhttp GET {{baseUrl}}/schedules/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/schedules/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/schedules/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all schedules
{{baseUrl}}/schedules
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/schedules");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/schedules")require "http/client"
url = "{{baseUrl}}/schedules"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/schedules"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/schedules");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/schedules"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/schedules HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/schedules")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/schedules"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/schedules")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/schedules")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/schedules');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/schedules'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/schedules';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/schedules',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/schedules")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/schedules',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/schedules'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/schedules');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/schedules'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/schedules';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/schedules"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/schedules" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/schedules",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/schedules');
echo $response->getBody();setUrl('{{baseUrl}}/schedules');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/schedules');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/schedules' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/schedules' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/schedules")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/schedules"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/schedules"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/schedules")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/schedules') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/schedules";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/scheduleshttp GET {{baseUrl}}/scheduleswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/schedulesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/schedules")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch the state of a schedule
{{baseUrl}}/schedules/:id/state
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/schedules/:id/state");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/schedules/:id/state")require "http/client"
url = "{{baseUrl}}/schedules/:id/state"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/schedules/:id/state"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/schedules/:id/state");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/schedules/:id/state"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/schedules/:id/state HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/schedules/:id/state")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/schedules/:id/state"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/schedules/:id/state")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/schedules/:id/state")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/schedules/:id/state');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/schedules/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/schedules/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/schedules/:id/state',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/schedules/:id/state")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/schedules/:id/state',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/schedules/:id/state'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/schedules/:id/state');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/schedules/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/schedules/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/schedules/:id/state"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/schedules/:id/state" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/schedules/:id/state",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/schedules/:id/state');
echo $response->getBody();setUrl('{{baseUrl}}/schedules/:id/state');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/schedules/:id/state');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/schedules/:id/state' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/schedules/:id/state' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/schedules/:id/state")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/schedules/:id/state"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/schedules/:id/state"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/schedules/:id/state")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/schedules/:id/state') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/schedules/:id/state";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/schedules/:id/statehttp GET {{baseUrl}}/schedules/:id/statewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/schedules/:id/stateimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/schedules/:id/state")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update a schedule
{{baseUrl}}/schedules/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/schedules/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/schedules/:id")require "http/client"
url = "{{baseUrl}}/schedules/:id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/schedules/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/schedules/:id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/schedules/:id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/schedules/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/schedules/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/schedules/:id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/schedules/:id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/schedules/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/schedules/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'PATCH', url: '{{baseUrl}}/schedules/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/schedules/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/schedules/:id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/schedules/:id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/schedules/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PATCH', url: '{{baseUrl}}/schedules/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/schedules/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PATCH', url: '{{baseUrl}}/schedules/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/schedules/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/schedules/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/schedules/:id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/schedules/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/schedules/:id');
echo $response->getBody();setUrl('{{baseUrl}}/schedules/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/schedules/:id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/schedules/:id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/schedules/:id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/schedules/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/schedules/:id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/schedules/:id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/schedules/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/schedules/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/schedules/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/schedules/:idhttp PATCH {{baseUrl}}/schedules/:idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/schedules/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/schedules/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch Swagger information
{{baseUrl}}/api/v1/specs
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/specs");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/api/v1/specs")require "http/client"
url = "{{baseUrl}}/api/v1/specs"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/api/v1/specs"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/api/v1/specs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/api/v1/specs"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/api/v1/specs HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/specs")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/api/v1/specs"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/api/v1/specs")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/specs")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/api/v1/specs');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/specs'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/api/v1/specs';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/api/v1/specs',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/api/v1/specs")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/api/v1/specs',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/specs'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/api/v1/specs');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/api/v1/specs'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/api/v1/specs';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/specs"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/api/v1/specs" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/api/v1/specs",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/api/v1/specs');
echo $response->getBody();setUrl('{{baseUrl}}/api/v1/specs');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/api/v1/specs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/specs' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/specs' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/api/v1/specs")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/api/v1/specs"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/api/v1/specs"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/api/v1/specs")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/api/v1/specs') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/api/v1/specs";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/api/v1/specshttp GET {{baseUrl}}/api/v1/specswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/api/v1/specsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/specs")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch peak recording storage
{{baseUrl}}/usage/storage/peak_recording
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usage/storage/peak_recording");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/usage/storage/peak_recording")require "http/client"
url = "{{baseUrl}}/usage/storage/peak_recording"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/usage/storage/peak_recording"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/usage/storage/peak_recording");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/usage/storage/peak_recording"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/usage/storage/peak_recording HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usage/storage/peak_recording")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/usage/storage/peak_recording"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/usage/storage/peak_recording")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/usage/storage/peak_recording")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/usage/storage/peak_recording');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/usage/storage/peak_recording'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/usage/storage/peak_recording';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/usage/storage/peak_recording',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/usage/storage/peak_recording")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/usage/storage/peak_recording',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/usage/storage/peak_recording'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/usage/storage/peak_recording');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/usage/storage/peak_recording'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/usage/storage/peak_recording';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/usage/storage/peak_recording"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/usage/storage/peak_recording" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/usage/storage/peak_recording",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/usage/storage/peak_recording');
echo $response->getBody();setUrl('{{baseUrl}}/usage/storage/peak_recording');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/usage/storage/peak_recording');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/usage/storage/peak_recording' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/usage/storage/peak_recording' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/usage/storage/peak_recording")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/usage/storage/peak_recording"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/usage/storage/peak_recording"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/usage/storage/peak_recording")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/usage/storage/peak_recording') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/usage/storage/peak_recording";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/usage/storage/peak_recordinghttp GET {{baseUrl}}/usage/storage/peak_recordingwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/usage/storage/peak_recordingimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usage/storage/peak_recording")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Add a stream source
{{baseUrl}}/stream_sources
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_sources");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/stream_sources")require "http/client"
url = "{{baseUrl}}/stream_sources"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/stream_sources"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_sources");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_sources"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/stream_sources HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/stream_sources")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_sources"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_sources")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/stream_sources")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/stream_sources');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/stream_sources'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_sources';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_sources',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_sources")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_sources',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/stream_sources'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/stream_sources');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/stream_sources'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_sources';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_sources"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_sources" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_sources",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/stream_sources');
echo $response->getBody();setUrl('{{baseUrl}}/stream_sources');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_sources');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_sources' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_sources' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/stream_sources")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_sources"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_sources"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_sources")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/stream_sources') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_sources";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/stream_sourceshttp POST {{baseUrl}}/stream_sourceswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/stream_sourcesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_sources")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a stream source
{{baseUrl}}/stream_sources/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_sources/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/stream_sources/:id")require "http/client"
url = "{{baseUrl}}/stream_sources/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/stream_sources/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_sources/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_sources/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/stream_sources/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/stream_sources/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_sources/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_sources/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/stream_sources/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/stream_sources/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/stream_sources/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_sources/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_sources/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_sources/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_sources/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'DELETE', url: '{{baseUrl}}/stream_sources/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/stream_sources/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'DELETE', url: '{{baseUrl}}/stream_sources/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_sources/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_sources/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_sources/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_sources/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/stream_sources/:id');
echo $response->getBody();setUrl('{{baseUrl}}/stream_sources/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_sources/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_sources/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_sources/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/stream_sources/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_sources/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_sources/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_sources/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/stream_sources/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_sources/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/stream_sources/:idhttp DELETE {{baseUrl}}/stream_sources/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/stream_sources/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_sources/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Deprecated operation
{{baseUrl}}/stream_sources/add
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_sources/add");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/stream_sources/add")require "http/client"
url = "{{baseUrl}}/stream_sources/add"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/stream_sources/add"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_sources/add");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_sources/add"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/stream_sources/add HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/stream_sources/add")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_sources/add"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_sources/add")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/stream_sources/add")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/stream_sources/add');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/stream_sources/add'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_sources/add';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_sources/add',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_sources/add")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_sources/add',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/stream_sources/add'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/stream_sources/add');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/stream_sources/add'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_sources/add';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_sources/add"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_sources/add" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_sources/add",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/stream_sources/add');
echo $response->getBody();setUrl('{{baseUrl}}/stream_sources/add');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_sources/add');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_sources/add' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_sources/add' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/stream_sources/add")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_sources/add"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_sources/add"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_sources/add")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/stream_sources/add') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_sources/add";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/stream_sources/addhttp POST {{baseUrl}}/stream_sources/addwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/stream_sources/addimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_sources/add")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a stream source
{{baseUrl}}/stream_sources/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_sources/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_sources/:id")require "http/client"
url = "{{baseUrl}}/stream_sources/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_sources/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_sources/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_sources/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_sources/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_sources/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_sources/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_sources/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_sources/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_sources/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/stream_sources/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_sources/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_sources/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_sources/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_sources/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/stream_sources/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_sources/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/stream_sources/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_sources/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_sources/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_sources/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_sources/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_sources/:id');
echo $response->getBody();setUrl('{{baseUrl}}/stream_sources/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_sources/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_sources/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_sources/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_sources/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_sources/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_sources/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_sources/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_sources/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_sources/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_sources/:idhttp GET {{baseUrl}}/stream_sources/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_sources/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_sources/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all stream sources
{{baseUrl}}/stream_sources
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_sources");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_sources")require "http/client"
url = "{{baseUrl}}/stream_sources"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_sources"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_sources");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_sources"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_sources HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_sources")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_sources"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_sources")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_sources")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_sources');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/stream_sources'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_sources';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_sources',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_sources")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_sources',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/stream_sources'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_sources');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/stream_sources'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_sources';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_sources"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_sources" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_sources",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_sources');
echo $response->getBody();setUrl('{{baseUrl}}/stream_sources');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_sources');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_sources' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_sources' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_sources")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_sources"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_sources"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_sources")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_sources') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_sources";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_sourceshttp GET {{baseUrl}}/stream_sourceswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_sourcesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_sources")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update a stream source
{{baseUrl}}/stream_sources/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_sources/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/stream_sources/:id")require "http/client"
url = "{{baseUrl}}/stream_sources/:id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/stream_sources/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_sources/:id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_sources/:id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/stream_sources/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/stream_sources/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_sources/:id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_sources/:id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/stream_sources/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/stream_sources/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'PATCH', url: '{{baseUrl}}/stream_sources/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_sources/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_sources/:id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_sources/:id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_sources/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PATCH', url: '{{baseUrl}}/stream_sources/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/stream_sources/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PATCH', url: '{{baseUrl}}/stream_sources/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_sources/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_sources/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_sources/:id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_sources/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/stream_sources/:id');
echo $response->getBody();setUrl('{{baseUrl}}/stream_sources/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_sources/:id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_sources/:id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_sources/:id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/stream_sources/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_sources/:id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_sources/:id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_sources/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/stream_sources/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_sources/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/stream_sources/:idhttp PATCH {{baseUrl}}/stream_sources/:idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/stream_sources/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_sources/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a property for a stream target
{{baseUrl}}/stream_targets/:stream_target_id/properties
QUERY PARAMS
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/properties");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/stream_targets/:stream_target_id/properties")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/properties"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/properties"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/properties");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/properties"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/stream_targets/:stream_target_id/properties HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/stream_targets/:stream_target_id/properties")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/properties"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/properties")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/stream_targets/:stream_target_id/properties")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/stream_targets/:stream_target_id/properties');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/properties';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/properties")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/properties',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/stream_targets/:stream_target_id/properties');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/properties';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/properties"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/properties" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/properties",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/stream_targets/:stream_target_id/properties');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/properties');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/properties');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/properties' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/properties' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/stream_targets/:stream_target_id/properties")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/properties"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/properties"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/properties")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/stream_targets/:stream_target_id/properties') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/properties";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/stream_targets/:stream_target_id/propertieshttp POST {{baseUrl}}/stream_targets/:stream_target_id/propertieswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/propertiesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/properties")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a stream target
{{baseUrl}}/stream_targets
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/stream_targets")require "http/client"
url = "{{baseUrl}}/stream_targets"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/stream_targets"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/stream_targets HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/stream_targets")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/stream_targets")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/stream_targets');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/stream_targets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/stream_targets'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/stream_targets');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/stream_targets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/stream_targets');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/stream_targets")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/stream_targets') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/stream_targetshttp POST {{baseUrl}}/stream_targetswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/stream_targetsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create geo-blocking for a stream target
{{baseUrl}}/stream_targets/:stream_target_id/geoblock
QUERY PARAMS
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/geoblock");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/stream_targets/:stream_target_id/geoblock")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/geoblock"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/geoblock");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/stream_targets/:stream_target_id/geoblock HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/geoblock"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/geoblock';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/geoblock',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/geoblock';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/geoblock"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/geoblock" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/geoblock",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/geoblock' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/geoblock' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/stream_targets/:stream_target_id/geoblock")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/stream_targets/:stream_target_id/geoblock') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/geoblock";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/stream_targets/:stream_target_id/geoblockhttp POST {{baseUrl}}/stream_targets/:stream_target_id/geoblockwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/geoblockimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/geoblock")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create token authorization for a stream target
{{baseUrl}}/stream_targets/:stream_target_id/token_auth
QUERY PARAMS
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/token_auth");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/stream_targets/:stream_target_id/token_auth")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/token_auth"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/token_auth");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/stream_targets/:stream_target_id/token_auth HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/token_auth"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/token_auth';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/token_auth',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/token_auth';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/token_auth"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/token_auth" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/token_auth",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/token_auth' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/token_auth' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/stream_targets/:stream_target_id/token_auth")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/stream_targets/:stream_target_id/token_auth') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/token_auth";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/stream_targets/:stream_target_id/token_authhttp POST {{baseUrl}}/stream_targets/:stream_target_id/token_authwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/token_authimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/token_auth")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a stream target property
{{baseUrl}}/stream_targets/:stream_target_id/properties/:id
QUERY PARAMS
stream_target_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/stream_targets/:stream_target_id/properties/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/properties/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/stream_targets/:stream_target_id/properties/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/stream_targets/:stream_target_id/properties/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/stream_targets/:stream_target_id/properties/:idhttp DELETE {{baseUrl}}/stream_targets/:stream_target_id/properties/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/properties/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a stream target
{{baseUrl}}/stream_targets/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/stream_targets/:id")require "http/client"
url = "{{baseUrl}}/stream_targets/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/stream_targets/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/stream_targets/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/stream_targets/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/stream_targets/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/stream_targets/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'DELETE', url: '{{baseUrl}}/stream_targets/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/stream_targets/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'DELETE', url: '{{baseUrl}}/stream_targets/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/stream_targets/:id');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/stream_targets/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/stream_targets/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/stream_targets/:idhttp DELETE {{baseUrl}}/stream_targets/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/stream_targets/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Deprecated operation (POST)
{{baseUrl}}/stream_targets/add
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/add");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/stream_targets/add")require "http/client"
url = "{{baseUrl}}/stream_targets/add"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/stream_targets/add"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/add");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/add"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/stream_targets/add HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/stream_targets/add")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/add"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/add")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/stream_targets/add")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/stream_targets/add');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/stream_targets/add'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/add';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/add',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/add")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/add',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/stream_targets/add'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/stream_targets/add');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/stream_targets/add'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/add';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/add"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/add" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/add",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/stream_targets/add');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/add');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/add');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/add' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/add' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/stream_targets/add")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/add"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/add"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/add")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/stream_targets/add') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/add";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/stream_targets/addhttp POST {{baseUrl}}/stream_targets/addwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/stream_targets/addimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/add")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a property of a stream target
{{baseUrl}}/stream_targets/:stream_target_id/properties/:id
QUERY PARAMS
stream_target_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_targets/:stream_target_id/properties/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/properties/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/properties/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/properties/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_targets/:stream_target_id/properties/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_targets/:stream_target_id/properties/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_targets/:stream_target_id/properties/:idhttp GET {{baseUrl}}/stream_targets/:stream_target_id/properties/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/properties/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/properties/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a stream target
{{baseUrl}}/stream_targets/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_targets/:id")require "http/client"
url = "{{baseUrl}}/stream_targets/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_targets/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_targets/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_targets/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_targets/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/stream_targets/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/stream_targets/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_targets/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/stream_targets/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_targets/:id');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_targets/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_targets/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_targets/:idhttp GET {{baseUrl}}/stream_targets/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_targets/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all properties of a stream target
{{baseUrl}}/stream_targets/:stream_target_id/properties
QUERY PARAMS
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/properties");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_targets/:stream_target_id/properties")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/properties"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/properties"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/properties");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/properties"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_targets/:stream_target_id/properties HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_targets/:stream_target_id/properties")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/properties"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/properties")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_targets/:stream_target_id/properties")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_targets/:stream_target_id/properties');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/properties';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/properties")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/properties',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_targets/:stream_target_id/properties');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/properties'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/properties';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/properties"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/properties" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/properties",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_targets/:stream_target_id/properties');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/properties');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/properties');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/properties' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/properties' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_targets/:stream_target_id/properties")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/properties"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/properties"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/properties")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_targets/:stream_target_id/properties') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/properties";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_targets/:stream_target_id/propertieshttp GET {{baseUrl}}/stream_targets/:stream_target_id/propertieswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/propertiesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/properties")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all stream targets
{{baseUrl}}/stream_targets
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_targets")require "http/client"
url = "{{baseUrl}}/stream_targets"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_targets"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_targets HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_targets")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_targets")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_targets');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/stream_targets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/stream_targets'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_targets');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/stream_targets'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_targets');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_targets")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_targets') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_targetshttp GET {{baseUrl}}/stream_targetswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_targetsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch current health metrics for an active Wowza ultra low latency stream target
{{baseUrl}}/stream_targets/:id/metrics/current
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:id/metrics/current");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_targets/:id/metrics/current")require "http/client"
url = "{{baseUrl}}/stream_targets/:id/metrics/current"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:id/metrics/current"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:id/metrics/current");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:id/metrics/current"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_targets/:id/metrics/current HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_targets/:id/metrics/current")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:id/metrics/current"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:id/metrics/current")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_targets/:id/metrics/current")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_targets/:id/metrics/current');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:id/metrics/current'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:id/metrics/current';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:id/metrics/current',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:id/metrics/current")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:id/metrics/current',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:id/metrics/current'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_targets/:id/metrics/current');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:id/metrics/current'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:id/metrics/current';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:id/metrics/current"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:id/metrics/current" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:id/metrics/current",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_targets/:id/metrics/current');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:id/metrics/current');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:id/metrics/current');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:id/metrics/current' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:id/metrics/current' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_targets/:id/metrics/current")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:id/metrics/current"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:id/metrics/current"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:id/metrics/current")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_targets/:id/metrics/current') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:id/metrics/current";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_targets/:id/metrics/currenthttp GET {{baseUrl}}/stream_targets/:id/metrics/currentwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_targets/:id/metrics/currentimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:id/metrics/current")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch geo-blocking for a stream target
{{baseUrl}}/stream_targets/:stream_target_id/geoblock
QUERY PARAMS
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/geoblock");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_targets/:stream_target_id/geoblock")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/geoblock"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/geoblock");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_targets/:stream_target_id/geoblock HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/geoblock"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/geoblock';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/geoblock',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/geoblock';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/geoblock"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/geoblock" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/geoblock",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/geoblock' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/geoblock' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_targets/:stream_target_id/geoblock")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_targets/:stream_target_id/geoblock') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/geoblock";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_targets/:stream_target_id/geoblockhttp GET {{baseUrl}}/stream_targets/:stream_target_id/geoblockwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/geoblockimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/geoblock")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch historic health metrics for a Wowza ultra low latency stream target
{{baseUrl}}/stream_targets/:id/metrics/historic
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:id/metrics/historic");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_targets/:id/metrics/historic")require "http/client"
url = "{{baseUrl}}/stream_targets/:id/metrics/historic"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:id/metrics/historic"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:id/metrics/historic");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:id/metrics/historic"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_targets/:id/metrics/historic HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_targets/:id/metrics/historic")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:id/metrics/historic"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:id/metrics/historic")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_targets/:id/metrics/historic")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_targets/:id/metrics/historic');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:id/metrics/historic'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:id/metrics/historic';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:id/metrics/historic',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:id/metrics/historic")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:id/metrics/historic',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:id/metrics/historic'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_targets/:id/metrics/historic');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:id/metrics/historic'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:id/metrics/historic';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:id/metrics/historic"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:id/metrics/historic" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:id/metrics/historic",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_targets/:id/metrics/historic');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:id/metrics/historic');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:id/metrics/historic');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:id/metrics/historic' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:id/metrics/historic' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_targets/:id/metrics/historic")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:id/metrics/historic"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:id/metrics/historic"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:id/metrics/historic")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_targets/:id/metrics/historic') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:id/metrics/historic";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_targets/:id/metrics/historichttp GET {{baseUrl}}/stream_targets/:id/metrics/historicwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_targets/:id/metrics/historicimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:id/metrics/historic")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch token authorization for a stream target
{{baseUrl}}/stream_targets/:stream_target_id/token_auth
QUERY PARAMS
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/token_auth");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stream_targets/:stream_target_id/token_auth")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/token_auth"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/token_auth");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stream_targets/:stream_target_id/token_auth HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/token_auth"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/token_auth';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/token_auth',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/token_auth';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/token_auth"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/token_auth" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/token_auth",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/token_auth' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/token_auth' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/stream_targets/:stream_target_id/token_auth")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stream_targets/:stream_target_id/token_auth') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/token_auth";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stream_targets/:stream_target_id/token_authhttp GET {{baseUrl}}/stream_targets/:stream_target_id/token_authwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/token_authimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/token_auth")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Regenerate the connection code for a stream target
{{baseUrl}}/stream_targets/:id/regenerate_connection_code
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:id/regenerate_connection_code");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/stream_targets/:id/regenerate_connection_code")require "http/client"
url = "{{baseUrl}}/stream_targets/:id/regenerate_connection_code"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:id/regenerate_connection_code"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:id/regenerate_connection_code");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:id/regenerate_connection_code"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/stream_targets/:id/regenerate_connection_code HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/stream_targets/:id/regenerate_connection_code")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:id/regenerate_connection_code"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:id/regenerate_connection_code")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/stream_targets/:id/regenerate_connection_code")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/stream_targets/:id/regenerate_connection_code');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/stream_targets/:id/regenerate_connection_code'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:id/regenerate_connection_code';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:id/regenerate_connection_code',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:id/regenerate_connection_code")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:id/regenerate_connection_code',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/stream_targets/:id/regenerate_connection_code'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/stream_targets/:id/regenerate_connection_code');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/stream_targets/:id/regenerate_connection_code'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:id/regenerate_connection_code';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:id/regenerate_connection_code"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:id/regenerate_connection_code" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:id/regenerate_connection_code",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/stream_targets/:id/regenerate_connection_code');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:id/regenerate_connection_code');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:id/regenerate_connection_code');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:id/regenerate_connection_code' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:id/regenerate_connection_code' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/stream_targets/:id/regenerate_connection_code")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:id/regenerate_connection_code"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:id/regenerate_connection_code"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:id/regenerate_connection_code")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/stream_targets/:id/regenerate_connection_code') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:id/regenerate_connection_code";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/stream_targets/:id/regenerate_connection_codehttp PUT {{baseUrl}}/stream_targets/:id/regenerate_connection_codewget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/stream_targets/:id/regenerate_connection_codeimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:id/regenerate_connection_code")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update a stream target
{{baseUrl}}/stream_targets/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/stream_targets/:id")require "http/client"
url = "{{baseUrl}}/stream_targets/:id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/stream_targets/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/stream_targets/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/stream_targets/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/stream_targets/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'PATCH', url: '{{baseUrl}}/stream_targets/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PATCH', url: '{{baseUrl}}/stream_targets/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/stream_targets/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PATCH', url: '{{baseUrl}}/stream_targets/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/stream_targets/:id');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/stream_targets/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/stream_targets/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/stream_targets/:idhttp PATCH {{baseUrl}}/stream_targets/:idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/stream_targets/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update geo-blocking for a stream target
{{baseUrl}}/stream_targets/:stream_target_id/geoblock
QUERY PARAMS
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/geoblock");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/stream_targets/:stream_target_id/geoblock")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/geoblock"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/geoblock");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/stream_targets/:stream_target_id/geoblock HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/geoblock"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/geoblock';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/geoblock',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/stream_targets/:stream_target_id/geoblock'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/geoblock';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/geoblock"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/geoblock" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/geoblock",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/geoblock');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/geoblock' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/geoblock' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/stream_targets/:stream_target_id/geoblock")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/geoblock"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/geoblock")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/stream_targets/:stream_target_id/geoblock') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/geoblock";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/stream_targets/:stream_target_id/geoblockhttp PATCH {{baseUrl}}/stream_targets/:stream_target_id/geoblockwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/geoblockimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/geoblock")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update token authorization for a stream target
{{baseUrl}}/stream_targets/:stream_target_id/token_auth
QUERY PARAMS
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stream_targets/:stream_target_id/token_auth");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/stream_targets/:stream_target_id/token_auth")require "http/client"
url = "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/stream_targets/:stream_target_id/token_auth"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stream_targets/:stream_target_id/token_auth");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/stream_targets/:stream_target_id/token_auth HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stream_targets/:stream_target_id/token_auth"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stream_targets/:stream_target_id/token_auth';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/stream_targets/:stream_target_id/token_auth',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/stream_targets/:stream_target_id/token_auth'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stream_targets/:stream_target_id/token_auth';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stream_targets/:stream_target_id/token_auth"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stream_targets/:stream_target_id/token_auth" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stream_targets/:stream_target_id/token_auth",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
echo $response->getBody();setUrl('{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stream_targets/:stream_target_id/token_auth');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/stream_targets/:stream_target_id/token_auth' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/stream_targets/:stream_target_id/token_auth' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/stream_targets/:stream_target_id/token_auth")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/stream_targets/:stream_target_id/token_auth"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stream_targets/:stream_target_id/token_auth")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/stream_targets/:stream_target_id/token_auth') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stream_targets/:stream_target_id/token_auth";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/stream_targets/:stream_target_id/token_authhttp PATCH {{baseUrl}}/stream_targets/:stream_target_id/token_authwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/stream_targets/:stream_target_id/token_authimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stream_targets/:stream_target_id/token_auth")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a property for a transcoder
{{baseUrl}}/transcoders/:transcoder_id/properties
QUERY PARAMS
transcoder_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/properties");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/transcoders/:transcoder_id/properties")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/properties"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/properties"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/properties");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/properties"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/transcoders/:transcoder_id/properties HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/transcoders/:transcoder_id/properties")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/properties"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/properties")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/transcoders/:transcoder_id/properties")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/transcoders/:transcoder_id/properties');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/properties';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/properties',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/properties")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/properties',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/transcoders/:transcoder_id/properties');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/properties';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/properties"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/properties" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/properties",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/transcoders/:transcoder_id/properties');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/properties');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/properties');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/properties' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/properties' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/transcoders/:transcoder_id/properties")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/properties"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/properties"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/properties")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/transcoders/:transcoder_id/properties') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/properties";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/transcoders/:transcoder_id/propertieshttp POST {{baseUrl}}/transcoders/:transcoder_id/propertieswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/propertiesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/properties")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a transcoder
{{baseUrl}}/transcoders
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/transcoders")require "http/client"
url = "{{baseUrl}}/transcoders"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/transcoders"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/transcoders HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/transcoders")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/transcoders")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/transcoders');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/transcoders'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/transcoders'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/transcoders');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/transcoders'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/transcoders');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/transcoders")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/transcoders') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/transcodershttp POST {{baseUrl}}/transcoderswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/transcodersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create an output stream target
{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets
QUERY PARAMS
transcoder_id
output_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targetshttp POST {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targetswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targetsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create an output
{{baseUrl}}/transcoders/:transcoder_id/outputs
QUERY PARAMS
transcoder_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/transcoders/:transcoder_id/outputs")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/transcoders/:transcoder_id/outputs HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/transcoders/:transcoder_id/outputs")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/transcoders/:transcoder_id/outputs")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/transcoders/:transcoder_id/outputs');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/transcoders/:transcoder_id/outputs');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/transcoders/:transcoder_id/outputs');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/transcoders/:transcoder_id/outputs")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/transcoders/:transcoder_id/outputs') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/transcoders/:transcoder_id/outputshttp POST {{baseUrl}}/transcoders/:transcoder_id/outputswget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a transcoder's property
{{baseUrl}}/transcoders/:transcoder_id/properties/:id
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/properties/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/transcoders/:transcoder_id/properties/:id")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/properties/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/properties/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/properties/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/properties/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/transcoders/:transcoder_id/properties/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/properties/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/properties/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/properties/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/properties/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/properties/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/properties/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/properties/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/properties/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/properties/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/properties/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/transcoders/:transcoder_id/properties/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/properties/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/properties/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/transcoders/:transcoder_id/properties/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/properties/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/transcoders/:transcoder_id/properties/:idhttp DELETE {{baseUrl}}/transcoders/:transcoder_id/properties/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/properties/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/properties/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete a transcoder
{{baseUrl}}/transcoders/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/transcoders/:id")require "http/client"
url = "{{baseUrl}}/transcoders/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/transcoders/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/transcoders/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/transcoders/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/transcoders/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'DELETE', url: '{{baseUrl}}/transcoders/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'DELETE', url: '{{baseUrl}}/transcoders/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/transcoders/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'DELETE', url: '{{baseUrl}}/transcoders/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/transcoders/:id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/transcoders/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/transcoders/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/transcoders/:idhttp DELETE {{baseUrl}}/transcoders/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/transcoders/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete an output stream target
{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id
QUERY PARAMS
transcoder_id
output_id
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_idhttp DELETE {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete an output
{{baseUrl}}/transcoders/:transcoder_id/outputs/:id
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/transcoders/:transcoder_id/outputs/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/transcoders/:transcoder_id/outputs/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/transcoders/:transcoder_id/outputs/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:idhttp DELETE {{baseUrl}}/transcoders/:transcoder_id/outputs/:idwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Deprecated operation (1)
{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/transcoders/:transcoder_id/outputs/:id/add_stream_target HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:id/add_stream_target',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/transcoders/:transcoder_id/outputs/:id/add_stream_target")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/transcoders/:transcoder_id/outputs/:id/add_stream_target') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_targethttp POST {{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_targetwget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_targetimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/add_stream_target")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Deprecated operation (DELETE)
{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target"
response = HTTP::Client.delete url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target"
req, _ := http.NewRequest("DELETE", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/transcoders/:transcoder_id/outputs/:id/remove_stream_target HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target"))
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target")
.delete(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target',
method: 'DELETE',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target")
.delete(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:id/remove_stream_target',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target';
const options = {method: 'DELETE'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target" in
Client.call `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target');
$request->setMethod(HTTP_METH_DELETE);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target' -Method DELETE $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target' -Method DELETE import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("DELETE", "/baseUrl/transcoders/:transcoder_id/outputs/:id/remove_stream_target")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target"
response = requests.delete(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target"
response <- VERB("DELETE", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/transcoders/:transcoder_id/outputs/:id/remove_stream_target') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_targethttp DELETE {{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_targetwget --quiet \
--method DELETE \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_targetimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id/remove_stream_target")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Disable a transcoder's stream targets
{{baseUrl}}/transcoders/:id/disable_all_stream_targets
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/disable_all_stream_targets");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/transcoders/:id/disable_all_stream_targets")require "http/client"
url = "{{baseUrl}}/transcoders/:id/disable_all_stream_targets"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/disable_all_stream_targets"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/disable_all_stream_targets");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/disable_all_stream_targets"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/transcoders/:id/disable_all_stream_targets HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/transcoders/:id/disable_all_stream_targets")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/disable_all_stream_targets"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/disable_all_stream_targets")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/transcoders/:id/disable_all_stream_targets")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/transcoders/:id/disable_all_stream_targets');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:id/disable_all_stream_targets'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/disable_all_stream_targets';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/disable_all_stream_targets',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/disable_all_stream_targets")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/disable_all_stream_targets',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:id/disable_all_stream_targets'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/transcoders/:id/disable_all_stream_targets');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:id/disable_all_stream_targets'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/disable_all_stream_targets';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/disable_all_stream_targets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/disable_all_stream_targets" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/disable_all_stream_targets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/transcoders/:id/disable_all_stream_targets');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/disable_all_stream_targets');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/disable_all_stream_targets');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/disable_all_stream_targets' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/disable_all_stream_targets' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/transcoders/:id/disable_all_stream_targets")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/disable_all_stream_targets"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/disable_all_stream_targets"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/disable_all_stream_targets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/transcoders/:id/disable_all_stream_targets') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/disable_all_stream_targets";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/transcoders/:id/disable_all_stream_targetshttp PUT {{baseUrl}}/transcoders/:id/disable_all_stream_targetswget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/transcoders/:id/disable_all_stream_targetsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/disable_all_stream_targets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Disable an output stream target
{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable
QUERY PARAMS
transcoder_id
output_id
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disablehttp PUT {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disablewget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disableimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/disable")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Enable a transcoder's stream targets
{{baseUrl}}/transcoders/:id/enable_all_stream_targets
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/enable_all_stream_targets");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/transcoders/:id/enable_all_stream_targets")require "http/client"
url = "{{baseUrl}}/transcoders/:id/enable_all_stream_targets"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/enable_all_stream_targets"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/enable_all_stream_targets");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/enable_all_stream_targets"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/transcoders/:id/enable_all_stream_targets HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/transcoders/:id/enable_all_stream_targets")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/enable_all_stream_targets"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/enable_all_stream_targets")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/transcoders/:id/enable_all_stream_targets")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/transcoders/:id/enable_all_stream_targets');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:id/enable_all_stream_targets'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/enable_all_stream_targets';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/enable_all_stream_targets',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/enable_all_stream_targets")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/enable_all_stream_targets',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:id/enable_all_stream_targets'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/transcoders/:id/enable_all_stream_targets');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:id/enable_all_stream_targets'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/enable_all_stream_targets';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/enable_all_stream_targets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/enable_all_stream_targets" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/enable_all_stream_targets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/transcoders/:id/enable_all_stream_targets');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/enable_all_stream_targets');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/enable_all_stream_targets');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/enable_all_stream_targets' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/enable_all_stream_targets' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/transcoders/:id/enable_all_stream_targets")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/enable_all_stream_targets"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/enable_all_stream_targets"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/enable_all_stream_targets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/transcoders/:id/enable_all_stream_targets') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/enable_all_stream_targets";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/transcoders/:id/enable_all_stream_targetshttp PUT {{baseUrl}}/transcoders/:id/enable_all_stream_targetswget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/transcoders/:id/enable_all_stream_targetsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/enable_all_stream_targets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Enable an output stream target
{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable
QUERY PARAMS
transcoder_id
output_id
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enablehttp PUT {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enablewget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enableimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/enable")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a property for a transcoder
{{baseUrl}}/transcoders/:transcoder_id/properties/:id
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/properties/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/properties/:id")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/properties/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/properties/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/properties/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/properties/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/properties/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/properties/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/properties/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/properties/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/properties/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/properties/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/properties/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/properties/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/properties/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/properties/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/properties/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/properties/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/properties/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/properties/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/properties/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/properties/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/properties/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/properties/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/properties/:idhttp GET {{baseUrl}}/transcoders/:transcoder_id/properties/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/properties/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/properties/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a transcoder's properties
{{baseUrl}}/transcoders/:transcoder_id/properties
QUERY PARAMS
transcoder_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/properties");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/properties")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/properties"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/properties"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/properties");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/properties"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/properties HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/properties")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/properties"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/properties")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/properties")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/properties');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/properties';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/properties',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/properties")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/properties',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/properties');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/properties'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/properties';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/properties"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/properties" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/properties",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/properties');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/properties');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/properties');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/properties' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/properties' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/properties")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/properties"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/properties"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/properties")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/properties') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/properties";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/propertieshttp GET {{baseUrl}}/transcoders/:transcoder_id/propertieswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/propertiesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/properties")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a transcoder's recordings
{{baseUrl}}/transcoders/:id/recordings
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/recordings");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:id/recordings")require "http/client"
url = "{{baseUrl}}/transcoders/:id/recordings"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/recordings"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/recordings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/recordings"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:id/recordings HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:id/recordings")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/recordings"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/recordings")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:id/recordings")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:id/recordings');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/recordings'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/recordings';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/recordings',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/recordings")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/recordings',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/recordings'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:id/recordings');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/recordings'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/recordings';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/recordings"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/recordings" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/recordings",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:id/recordings');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/recordings');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/recordings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/recordings' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/recordings' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:id/recordings")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/recordings"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/recordings"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/recordings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:id/recordings') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/recordings";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:id/recordingshttp GET {{baseUrl}}/transcoders/:id/recordingswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:id/recordingsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/recordings")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch a transcoder
{{baseUrl}}/transcoders/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:id")require "http/client"
url = "{{baseUrl}}/transcoders/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:idhttp GET {{baseUrl}}/transcoders/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all output stream targets of an output of a transcoder
{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets
QUERY PARAMS
transcoder_id
output_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targetshttp GET {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targetswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targetsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all outputs of a transcoder
{{baseUrl}}/transcoders/:transcoder_id/outputs
QUERY PARAMS
transcoder_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/outputs")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/outputs HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/outputs")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/outputs")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/outputs")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/outputs') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/outputshttp GET {{baseUrl}}/transcoders/:transcoder_id/outputswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all transcoders
{{baseUrl}}/transcoders
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders")require "http/client"
url = "{{baseUrl}}/transcoders"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/transcoders'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/transcoders'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/transcoders'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcodershttp GET {{baseUrl}}/transcoderswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcodersimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch all uptime records for a transcoder
{{baseUrl}}/transcoders/:transcoder_id/uptimes
QUERY PARAMS
transcoder_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/uptimes");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/uptimes")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/uptimes"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/uptimes");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/uptimes"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/uptimes HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/uptimes")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/uptimes"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/uptimes")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/uptimes")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/uptimes';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/uptimes")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/uptimes',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/uptimes';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/uptimes"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/uptimes" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/uptimes",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/uptimes');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/uptimes');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/uptimes' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/uptimes' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/uptimes")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/uptimes"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/uptimes")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/uptimes') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/uptimeshttp GET {{baseUrl}}/transcoders/:transcoder_id/uptimeswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/uptimesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/uptimes")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch an output stream target
{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id
QUERY PARAMS
transcoder_id
output_id
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_idhttp GET {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch an output
{{baseUrl}}/transcoders/:transcoder_id/outputs/:id
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/outputs/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/outputs/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/outputs/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:idhttp GET {{baseUrl}}/transcoders/:transcoder_id/outputs/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch an uptime record
{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/uptimes/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/uptimes/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/uptimes/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/uptimes/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/uptimes/:idhttp GET {{baseUrl}}/transcoders/:transcoder_id/uptimes/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/uptimes/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch current stream health metrics for an active transcoder
{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/uptimes/:id/metrics/current HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/uptimes/:id/metrics/current',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/uptimes/:id/metrics/current")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/uptimes/:id/metrics/current') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/currenthttp GET {{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/currentwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/currentimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/current")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch historic stream health metrics for a transcoder
{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:transcoder_id/uptimes/:id/metrics/historic HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/uptimes/:id/metrics/historic',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:transcoder_id/uptimes/:id/metrics/historic")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:transcoder_id/uptimes/:id/metrics/historic') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historichttp GET {{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historicwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historicimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/uptimes/:id/metrics/historic")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch statistics for a current transcoder
{{baseUrl}}/transcoders/:id/stats
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/stats");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:id/stats")require "http/client"
url = "{{baseUrl}}/transcoders/:id/stats"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/stats"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/stats");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/stats"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:id/stats HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:id/stats")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/stats"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/stats")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:id/stats")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:id/stats');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/stats'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/stats';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/stats',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/stats")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/stats',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/stats'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:id/stats');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/stats'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/stats';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/stats"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/stats" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/stats",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:id/stats');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/stats');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/stats');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/stats' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/stats' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:id/stats")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/stats"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/stats"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/stats")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:id/stats') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/stats";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:id/statshttp GET {{baseUrl}}/transcoders/:id/statswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:id/statsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/stats")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch the state and uptime ID of a transcoder
{{baseUrl}}/transcoders/:id/state
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/state");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:id/state")require "http/client"
url = "{{baseUrl}}/transcoders/:id/state"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/state"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/state");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/state"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:id/state HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:id/state")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/state"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/state")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:id/state")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:id/state');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/state',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/state")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/state',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/state'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:id/state');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/state'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/state';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/state"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/state" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/state",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:id/state');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/state');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/state');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/state' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/state' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:id/state")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/state"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/state"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/state")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:id/state') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/state";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:id/statehttp GET {{baseUrl}}/transcoders/:id/statewget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:id/stateimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/state")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch the thumbnail URL of a transcoder
{{baseUrl}}/transcoders/:id/thumbnail_url
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/thumbnail_url");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:id/thumbnail_url")require "http/client"
url = "{{baseUrl}}/transcoders/:id/thumbnail_url"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/thumbnail_url"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/thumbnail_url");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/thumbnail_url"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:id/thumbnail_url HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:id/thumbnail_url")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/thumbnail_url"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/thumbnail_url")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:id/thumbnail_url")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:id/thumbnail_url');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:id/thumbnail_url'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/thumbnail_url';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/thumbnail_url',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/thumbnail_url")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/thumbnail_url',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:id/thumbnail_url'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:id/thumbnail_url');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/transcoders/:id/thumbnail_url'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/thumbnail_url';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/thumbnail_url"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/thumbnail_url" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/thumbnail_url",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:id/thumbnail_url');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/thumbnail_url');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/thumbnail_url');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/thumbnail_url' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/thumbnail_url' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:id/thumbnail_url")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/thumbnail_url"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/thumbnail_url"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/thumbnail_url")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:id/thumbnail_url') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/thumbnail_url";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:id/thumbnail_urlhttp GET {{baseUrl}}/transcoders/:id/thumbnail_urlwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:id/thumbnail_urlimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/thumbnail_url")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch transcoder's schedules
{{baseUrl}}/transcoders/:id/schedules
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/schedules");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/transcoders/:id/schedules")require "http/client"
url = "{{baseUrl}}/transcoders/:id/schedules"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/schedules"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/schedules");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/schedules"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/transcoders/:id/schedules HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/transcoders/:id/schedules")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/schedules"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/schedules")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/transcoders/:id/schedules")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/transcoders/:id/schedules');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/schedules'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/schedules';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/schedules',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/schedules")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/schedules',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/schedules'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/transcoders/:id/schedules');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'GET', url: '{{baseUrl}}/transcoders/:id/schedules'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/schedules';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/schedules"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/schedules" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/schedules",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/transcoders/:id/schedules');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/schedules');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/schedules');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/schedules' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/schedules' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/transcoders/:id/schedules")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/schedules"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/schedules"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/schedules")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/transcoders/:id/schedules') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/schedules";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/transcoders/:id/scheduleshttp GET {{baseUrl}}/transcoders/:id/scheduleswget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/transcoders/:id/schedulesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/schedules")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Reset a transcoder
{{baseUrl}}/transcoders/:id/reset
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/reset");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/transcoders/:id/reset")require "http/client"
url = "{{baseUrl}}/transcoders/:id/reset"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/reset"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/reset");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/reset"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/transcoders/:id/reset HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/transcoders/:id/reset")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/reset"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/reset")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/transcoders/:id/reset")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/transcoders/:id/reset');
xhr.send(data);import axios from 'axios';
const options = {method: 'PUT', url: '{{baseUrl}}/transcoders/:id/reset'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/reset';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/reset',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/reset")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/reset',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PUT', url: '{{baseUrl}}/transcoders/:id/reset'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/transcoders/:id/reset');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PUT', url: '{{baseUrl}}/transcoders/:id/reset'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/reset';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/reset"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/reset" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/reset",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/transcoders/:id/reset');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/reset');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/reset');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/reset' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/reset' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/transcoders/:id/reset")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/reset"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/reset"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/reset")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/transcoders/:id/reset') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/reset";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/transcoders/:id/resethttp PUT {{baseUrl}}/transcoders/:id/resetwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/transcoders/:id/resetimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/reset")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Restart an output stream target
{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart
QUERY PARAMS
transcoder_id
output_id
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restarthttp PUT {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restartwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restartimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id/restart")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Start a transcoder
{{baseUrl}}/transcoders/:id/start
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/start");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/transcoders/:id/start")require "http/client"
url = "{{baseUrl}}/transcoders/:id/start"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/start"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/start");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/start"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/transcoders/:id/start HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/transcoders/:id/start")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/start"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/start")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/transcoders/:id/start")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/transcoders/:id/start');
xhr.send(data);import axios from 'axios';
const options = {method: 'PUT', url: '{{baseUrl}}/transcoders/:id/start'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/start';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/start',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/start")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/start',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PUT', url: '{{baseUrl}}/transcoders/:id/start'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/transcoders/:id/start');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PUT', url: '{{baseUrl}}/transcoders/:id/start'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/start';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/start"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/start" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/start",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/transcoders/:id/start');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/start');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/start');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/start' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/start' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/transcoders/:id/start")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/start"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/start"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/start")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/transcoders/:id/start') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/start";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/transcoders/:id/starthttp PUT {{baseUrl}}/transcoders/:id/startwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/transcoders/:id/startimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/start")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Stop a transcoder
{{baseUrl}}/transcoders/:id/stop
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id/stop");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/transcoders/:id/stop")require "http/client"
url = "{{baseUrl}}/transcoders/:id/stop"
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id/stop"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id/stop");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id/stop"
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/transcoders/:id/stop HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/transcoders/:id/stop")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id/stop"))
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id/stop")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/transcoders/:id/stop")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/transcoders/:id/stop');
xhr.send(data);import axios from 'axios';
const options = {method: 'PUT', url: '{{baseUrl}}/transcoders/:id/stop'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id/stop';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id/stop',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id/stop")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id/stop',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PUT', url: '{{baseUrl}}/transcoders/:id/stop'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/transcoders/:id/stop');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PUT', url: '{{baseUrl}}/transcoders/:id/stop'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id/stop';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id/stop"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id/stop" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id/stop",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/transcoders/:id/stop');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id/stop');
$request->setMethod(HTTP_METH_PUT);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id/stop');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id/stop' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id/stop' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/transcoders/:id/stop")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id/stop"
response = requests.put(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id/stop"
response <- VERB("PUT", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id/stop")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/transcoders/:id/stop') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id/stop";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/transcoders/:id/stophttp PUT {{baseUrl}}/transcoders/:id/stopwget --quiet \
--method PUT \
--output-document \
- {{baseUrl}}/transcoders/:id/stopimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id/stop")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update a transcoder
{{baseUrl}}/transcoders/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/transcoders/:id")require "http/client"
url = "{{baseUrl}}/transcoders/:id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/transcoders/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/transcoders/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/transcoders/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/transcoders/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/transcoders/:id');
xhr.send(data);import axios from 'axios';
const options = {method: 'PATCH', url: '{{baseUrl}}/transcoders/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'PATCH', url: '{{baseUrl}}/transcoders/:id'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/transcoders/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'PATCH', url: '{{baseUrl}}/transcoders/:id'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/transcoders/:id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/transcoders/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/transcoders/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/transcoders/:idhttp PATCH {{baseUrl}}/transcoders/:idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/transcoders/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update an output stream target
{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id
QUERY PARAMS
transcoder_id
output_id
stream_target_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_idhttp PATCH {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:output_id/output_stream_targets/:stream_target_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PATCH
Update an output
{{baseUrl}}/transcoders/:transcoder_id/outputs/:id
QUERY PARAMS
transcoder_id
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/patch "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")require "http/client"
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
response = HTTP::Client.patch url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Patch,
RequestUri = new Uri("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id");
var request = new RestRequest("", Method.Patch);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
req, _ := http.NewRequest("PATCH", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PATCH /baseUrl/transcoders/:transcoder_id/outputs/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"))
.method("PATCH", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.patch(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.patch("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PATCH', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PATCH',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id',
method: 'PATCH',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
.patch(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PATCH',
hostname: 'example.com',
port: null,
path: '/baseUrl/transcoders/:transcoder_id/outputs/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PATCH',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PATCH', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PATCH',
url: '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id';
const options = {method: 'PATCH'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id" in
Client.call `PATCH uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PATCH",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PATCH', '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
echo $response->getBody();setUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/transcoders/:transcoder_id/outputs/:id');
$request->setRequestMethod('PATCH');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id' -Method PATCH $response = Invoke-RestMethod -Uri '{{baseUrl}}/transcoders/:transcoder_id/outputs/:id' -Method PATCH import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PATCH", "/baseUrl/transcoders/:transcoder_id/outputs/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
response = requests.patch(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id"
response <- VERB("PATCH", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Patch.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.patch('/baseUrl/transcoders/:transcoder_id/outputs/:id') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PATCH \
--url {{baseUrl}}/transcoders/:transcoder_id/outputs/:idhttp PATCH {{baseUrl}}/transcoders/:transcoder_id/outputs/:idwget --quiet \
--method PATCH \
--output-document \
- {{baseUrl}}/transcoders/:transcoder_id/outputs/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transcoders/:transcoder_id/outputs/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Fetch viewer data for a stream target
{{baseUrl}}/usage/viewer_data/stream_targets/:id
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/usage/viewer_data/stream_targets/:id");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/usage/viewer_data/stream_targets/:id")require "http/client"
url = "{{baseUrl}}/usage/viewer_data/stream_targets/:id"
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/usage/viewer_data/stream_targets/:id"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/usage/viewer_data/stream_targets/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/usage/viewer_data/stream_targets/:id"
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/usage/viewer_data/stream_targets/:id HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/usage/viewer_data/stream_targets/:id")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/usage/viewer_data/stream_targets/:id"))
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/usage/viewer_data/stream_targets/:id")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/usage/viewer_data/stream_targets/:id")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/usage/viewer_data/stream_targets/:id');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/usage/viewer_data/stream_targets/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/usage/viewer_data/stream_targets/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/usage/viewer_data/stream_targets/:id',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/usage/viewer_data/stream_targets/:id")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/usage/viewer_data/stream_targets/:id',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/usage/viewer_data/stream_targets/:id'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/usage/viewer_data/stream_targets/:id');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/usage/viewer_data/stream_targets/:id'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/usage/viewer_data/stream_targets/:id';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/usage/viewer_data/stream_targets/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/usage/viewer_data/stream_targets/:id" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/usage/viewer_data/stream_targets/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/usage/viewer_data/stream_targets/:id');
echo $response->getBody();setUrl('{{baseUrl}}/usage/viewer_data/stream_targets/:id');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/usage/viewer_data/stream_targets/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/usage/viewer_data/stream_targets/:id' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/usage/viewer_data/stream_targets/:id' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/usage/viewer_data/stream_targets/:id")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/usage/viewer_data/stream_targets/:id"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/usage/viewer_data/stream_targets/:id"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/usage/viewer_data/stream_targets/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/usage/viewer_data/stream_targets/:id') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/usage/viewer_data/stream_targets/:id";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/usage/viewer_data/stream_targets/:idhttp GET {{baseUrl}}/usage/viewer_data/stream_targets/:idwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/usage/viewer_data/stream_targets/:idimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/usage/viewer_data/stream_targets/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()