Amazon Kinesis Video Streams Archived Media
POST
GetClip
{{baseUrl}}/getClip
BODY json
{
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getClip");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/getClip" {:content-type :json
:form-params {:StreamName ""
:StreamARN ""
:ClipFragmentSelector {:FragmentSelectorType ""
:TimestampRange ""}}})require "http/client"
url = "{{baseUrl}}/getClip"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/getClip"),
Content = new StringContent("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getClip");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getClip"
payload := strings.NewReader("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/getClip HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 131
{
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getClip")
.setHeader("content-type", "application/json")
.setBody("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getClip"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/getClip")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/getClip")
.header("content-type", "application/json")
.body("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
.asString(); const data = JSON.stringify({
StreamName: '',
StreamARN: '',
ClipFragmentSelector: {
FragmentSelectorType: '',
TimestampRange: ''
}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/getClip');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/getClip',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
ClipFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getClip';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","ClipFragmentSelector":{"FragmentSelectorType":"","TimestampRange":""}}'
};
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}}/getClip',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "StreamName": "",\n "StreamARN": "",\n "ClipFragmentSelector": {\n "FragmentSelectorType": "",\n "TimestampRange": ""\n }\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
val request = Request.Builder()
.url("{{baseUrl}}/getClip")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/getClip',
headers: {
'content-type': 'application/json'
}
};
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.write(JSON.stringify({
StreamName: '',
StreamARN: '',
ClipFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''}
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/getClip',
headers: {'content-type': 'application/json'},
body: {
StreamName: '',
StreamARN: '',
ClipFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''}
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/getClip');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
StreamName: '',
StreamARN: '',
ClipFragmentSelector: {
FragmentSelectorType: '',
TimestampRange: ''
}
});
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}}/getClip',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
ClipFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getClip';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","ClipFragmentSelector":{"FragmentSelectorType":"","TimestampRange":""}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StreamName": @"",
@"StreamARN": @"",
@"ClipFragmentSelector": @{ @"FragmentSelectorType": @"", @"TimestampRange": @"" } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getClip"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
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}}/getClip" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getClip",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'StreamName' => '',
'StreamARN' => '',
'ClipFragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/getClip', [
'body' => '{
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/getClip');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'StreamName' => '',
'StreamARN' => '',
'ClipFragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'StreamName' => '',
'StreamARN' => '',
'ClipFragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
]
]));
$request->setRequestUrl('{{baseUrl}}/getClip');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/getClip' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getClip' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/getClip", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getClip"
payload = {
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/getClip"
payload <- "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getClip")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/getClip') do |req|
req.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ClipFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getClip";
let payload = json!({
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": json!({
"FragmentSelectorType": "",
"TimestampRange": ""
})
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/getClip \
--header 'content-type: application/json' \
--data '{
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}'echo '{
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}' | \
http POST {{baseUrl}}/getClip \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "StreamName": "",\n "StreamARN": "",\n "ClipFragmentSelector": {\n "FragmentSelectorType": "",\n "TimestampRange": ""\n }\n}' \
--output-document \
- {{baseUrl}}/getClipimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"StreamName": "",
"StreamARN": "",
"ClipFragmentSelector": [
"FragmentSelectorType": "",
"TimestampRange": ""
]
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getClip")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
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
GetDASHStreamingSessionURL
{{baseUrl}}/getDASHStreamingSessionURL
BODY json
{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"Expires": 0,
"MaxManifestFragmentResults": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getDASHStreamingSessionURL");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/getDASHStreamingSessionURL" {:content-type :json
:form-params {:StreamName ""
:StreamARN ""
:PlaybackMode ""
:DisplayFragmentTimestamp ""
:DisplayFragmentNumber ""
:DASHFragmentSelector {:FragmentSelectorType ""
:TimestampRange ""}
:Expires 0
:MaxManifestFragmentResults 0}})require "http/client"
url = "{{baseUrl}}/getDASHStreamingSessionURL"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/getDASHStreamingSessionURL"),
Content = new StringContent("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getDASHStreamingSessionURL");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getDASHStreamingSessionURL"
payload := strings.NewReader("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/getDASHStreamingSessionURL HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 269
{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"Expires": 0,
"MaxManifestFragmentResults": 0
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getDASHStreamingSessionURL")
.setHeader("content-type", "application/json")
.setBody("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getDASHStreamingSessionURL"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/getDASHStreamingSessionURL")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/getDASHStreamingSessionURL")
.header("content-type", "application/json")
.body("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}")
.asString(); const data = JSON.stringify({
StreamName: '',
StreamARN: '',
PlaybackMode: '',
DisplayFragmentTimestamp: '',
DisplayFragmentNumber: '',
DASHFragmentSelector: {
FragmentSelectorType: '',
TimestampRange: ''
},
Expires: 0,
MaxManifestFragmentResults: 0
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/getDASHStreamingSessionURL');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/getDASHStreamingSessionURL',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
PlaybackMode: '',
DisplayFragmentTimestamp: '',
DisplayFragmentNumber: '',
DASHFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''},
Expires: 0,
MaxManifestFragmentResults: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getDASHStreamingSessionURL';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","PlaybackMode":"","DisplayFragmentTimestamp":"","DisplayFragmentNumber":"","DASHFragmentSelector":{"FragmentSelectorType":"","TimestampRange":""},"Expires":0,"MaxManifestFragmentResults":0}'
};
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}}/getDASHStreamingSessionURL',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "StreamName": "",\n "StreamARN": "",\n "PlaybackMode": "",\n "DisplayFragmentTimestamp": "",\n "DisplayFragmentNumber": "",\n "DASHFragmentSelector": {\n "FragmentSelectorType": "",\n "TimestampRange": ""\n },\n "Expires": 0,\n "MaxManifestFragmentResults": 0\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}")
val request = Request.Builder()
.url("{{baseUrl}}/getDASHStreamingSessionURL")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/getDASHStreamingSessionURL',
headers: {
'content-type': 'application/json'
}
};
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.write(JSON.stringify({
StreamName: '',
StreamARN: '',
PlaybackMode: '',
DisplayFragmentTimestamp: '',
DisplayFragmentNumber: '',
DASHFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''},
Expires: 0,
MaxManifestFragmentResults: 0
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/getDASHStreamingSessionURL',
headers: {'content-type': 'application/json'},
body: {
StreamName: '',
StreamARN: '',
PlaybackMode: '',
DisplayFragmentTimestamp: '',
DisplayFragmentNumber: '',
DASHFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''},
Expires: 0,
MaxManifestFragmentResults: 0
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/getDASHStreamingSessionURL');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
StreamName: '',
StreamARN: '',
PlaybackMode: '',
DisplayFragmentTimestamp: '',
DisplayFragmentNumber: '',
DASHFragmentSelector: {
FragmentSelectorType: '',
TimestampRange: ''
},
Expires: 0,
MaxManifestFragmentResults: 0
});
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}}/getDASHStreamingSessionURL',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
PlaybackMode: '',
DisplayFragmentTimestamp: '',
DisplayFragmentNumber: '',
DASHFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''},
Expires: 0,
MaxManifestFragmentResults: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getDASHStreamingSessionURL';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","PlaybackMode":"","DisplayFragmentTimestamp":"","DisplayFragmentNumber":"","DASHFragmentSelector":{"FragmentSelectorType":"","TimestampRange":""},"Expires":0,"MaxManifestFragmentResults":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StreamName": @"",
@"StreamARN": @"",
@"PlaybackMode": @"",
@"DisplayFragmentTimestamp": @"",
@"DisplayFragmentNumber": @"",
@"DASHFragmentSelector": @{ @"FragmentSelectorType": @"", @"TimestampRange": @"" },
@"Expires": @0,
@"MaxManifestFragmentResults": @0 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getDASHStreamingSessionURL"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
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}}/getDASHStreamingSessionURL" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getDASHStreamingSessionURL",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'StreamName' => '',
'StreamARN' => '',
'PlaybackMode' => '',
'DisplayFragmentTimestamp' => '',
'DisplayFragmentNumber' => '',
'DASHFragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
],
'Expires' => 0,
'MaxManifestFragmentResults' => 0
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/getDASHStreamingSessionURL', [
'body' => '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"Expires": 0,
"MaxManifestFragmentResults": 0
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/getDASHStreamingSessionURL');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'StreamName' => '',
'StreamARN' => '',
'PlaybackMode' => '',
'DisplayFragmentTimestamp' => '',
'DisplayFragmentNumber' => '',
'DASHFragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
],
'Expires' => 0,
'MaxManifestFragmentResults' => 0
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'StreamName' => '',
'StreamARN' => '',
'PlaybackMode' => '',
'DisplayFragmentTimestamp' => '',
'DisplayFragmentNumber' => '',
'DASHFragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
],
'Expires' => 0,
'MaxManifestFragmentResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/getDASHStreamingSessionURL');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/getDASHStreamingSessionURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"Expires": 0,
"MaxManifestFragmentResults": 0
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getDASHStreamingSessionURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"Expires": 0,
"MaxManifestFragmentResults": 0
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/getDASHStreamingSessionURL", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getDASHStreamingSessionURL"
payload = {
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"Expires": 0,
"MaxManifestFragmentResults": 0
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/getDASHStreamingSessionURL"
payload <- "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getDASHStreamingSessionURL")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/getDASHStreamingSessionURL') do |req|
req.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"DisplayFragmentNumber\": \"\",\n \"DASHFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"Expires\": 0,\n \"MaxManifestFragmentResults\": 0\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getDASHStreamingSessionURL";
let payload = json!({
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": json!({
"FragmentSelectorType": "",
"TimestampRange": ""
}),
"Expires": 0,
"MaxManifestFragmentResults": 0
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/getDASHStreamingSessionURL \
--header 'content-type: application/json' \
--data '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"Expires": 0,
"MaxManifestFragmentResults": 0
}'echo '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"Expires": 0,
"MaxManifestFragmentResults": 0
}' | \
http POST {{baseUrl}}/getDASHStreamingSessionURL \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "StreamName": "",\n "StreamARN": "",\n "PlaybackMode": "",\n "DisplayFragmentTimestamp": "",\n "DisplayFragmentNumber": "",\n "DASHFragmentSelector": {\n "FragmentSelectorType": "",\n "TimestampRange": ""\n },\n "Expires": 0,\n "MaxManifestFragmentResults": 0\n}' \
--output-document \
- {{baseUrl}}/getDASHStreamingSessionURLimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"DisplayFragmentTimestamp": "",
"DisplayFragmentNumber": "",
"DASHFragmentSelector": [
"FragmentSelectorType": "",
"TimestampRange": ""
],
"Expires": 0,
"MaxManifestFragmentResults": 0
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getDASHStreamingSessionURL")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
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
GetHLSStreamingSessionURL
{{baseUrl}}/getHLSStreamingSessionURL
BODY json
{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getHLSStreamingSessionURL");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/getHLSStreamingSessionURL" {:content-type :json
:form-params {:StreamName ""
:StreamARN ""
:PlaybackMode ""
:HLSFragmentSelector {:FragmentSelectorType ""
:TimestampRange ""}
:ContainerFormat ""
:DiscontinuityMode ""
:DisplayFragmentTimestamp ""
:Expires 0
:MaxMediaPlaylistFragmentResults 0}})require "http/client"
url = "{{baseUrl}}/getHLSStreamingSessionURL"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/getHLSStreamingSessionURL"),
Content = new StringContent("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getHLSStreamingSessionURL");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getHLSStreamingSessionURL"
payload := strings.NewReader("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/getHLSStreamingSessionURL HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 294
{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getHLSStreamingSessionURL")
.setHeader("content-type", "application/json")
.setBody("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getHLSStreamingSessionURL"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/getHLSStreamingSessionURL")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/getHLSStreamingSessionURL")
.header("content-type", "application/json")
.body("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}")
.asString(); const data = JSON.stringify({
StreamName: '',
StreamARN: '',
PlaybackMode: '',
HLSFragmentSelector: {
FragmentSelectorType: '',
TimestampRange: ''
},
ContainerFormat: '',
DiscontinuityMode: '',
DisplayFragmentTimestamp: '',
Expires: 0,
MaxMediaPlaylistFragmentResults: 0
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/getHLSStreamingSessionURL');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/getHLSStreamingSessionURL',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
PlaybackMode: '',
HLSFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''},
ContainerFormat: '',
DiscontinuityMode: '',
DisplayFragmentTimestamp: '',
Expires: 0,
MaxMediaPlaylistFragmentResults: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getHLSStreamingSessionURL';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","PlaybackMode":"","HLSFragmentSelector":{"FragmentSelectorType":"","TimestampRange":""},"ContainerFormat":"","DiscontinuityMode":"","DisplayFragmentTimestamp":"","Expires":0,"MaxMediaPlaylistFragmentResults":0}'
};
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}}/getHLSStreamingSessionURL',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "StreamName": "",\n "StreamARN": "",\n "PlaybackMode": "",\n "HLSFragmentSelector": {\n "FragmentSelectorType": "",\n "TimestampRange": ""\n },\n "ContainerFormat": "",\n "DiscontinuityMode": "",\n "DisplayFragmentTimestamp": "",\n "Expires": 0,\n "MaxMediaPlaylistFragmentResults": 0\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}")
val request = Request.Builder()
.url("{{baseUrl}}/getHLSStreamingSessionURL")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/getHLSStreamingSessionURL',
headers: {
'content-type': 'application/json'
}
};
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.write(JSON.stringify({
StreamName: '',
StreamARN: '',
PlaybackMode: '',
HLSFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''},
ContainerFormat: '',
DiscontinuityMode: '',
DisplayFragmentTimestamp: '',
Expires: 0,
MaxMediaPlaylistFragmentResults: 0
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/getHLSStreamingSessionURL',
headers: {'content-type': 'application/json'},
body: {
StreamName: '',
StreamARN: '',
PlaybackMode: '',
HLSFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''},
ContainerFormat: '',
DiscontinuityMode: '',
DisplayFragmentTimestamp: '',
Expires: 0,
MaxMediaPlaylistFragmentResults: 0
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/getHLSStreamingSessionURL');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
StreamName: '',
StreamARN: '',
PlaybackMode: '',
HLSFragmentSelector: {
FragmentSelectorType: '',
TimestampRange: ''
},
ContainerFormat: '',
DiscontinuityMode: '',
DisplayFragmentTimestamp: '',
Expires: 0,
MaxMediaPlaylistFragmentResults: 0
});
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}}/getHLSStreamingSessionURL',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
PlaybackMode: '',
HLSFragmentSelector: {FragmentSelectorType: '', TimestampRange: ''},
ContainerFormat: '',
DiscontinuityMode: '',
DisplayFragmentTimestamp: '',
Expires: 0,
MaxMediaPlaylistFragmentResults: 0
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getHLSStreamingSessionURL';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","PlaybackMode":"","HLSFragmentSelector":{"FragmentSelectorType":"","TimestampRange":""},"ContainerFormat":"","DiscontinuityMode":"","DisplayFragmentTimestamp":"","Expires":0,"MaxMediaPlaylistFragmentResults":0}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StreamName": @"",
@"StreamARN": @"",
@"PlaybackMode": @"",
@"HLSFragmentSelector": @{ @"FragmentSelectorType": @"", @"TimestampRange": @"" },
@"ContainerFormat": @"",
@"DiscontinuityMode": @"",
@"DisplayFragmentTimestamp": @"",
@"Expires": @0,
@"MaxMediaPlaylistFragmentResults": @0 };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getHLSStreamingSessionURL"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
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}}/getHLSStreamingSessionURL" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getHLSStreamingSessionURL",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'StreamName' => '',
'StreamARN' => '',
'PlaybackMode' => '',
'HLSFragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
],
'ContainerFormat' => '',
'DiscontinuityMode' => '',
'DisplayFragmentTimestamp' => '',
'Expires' => 0,
'MaxMediaPlaylistFragmentResults' => 0
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/getHLSStreamingSessionURL', [
'body' => '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/getHLSStreamingSessionURL');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'StreamName' => '',
'StreamARN' => '',
'PlaybackMode' => '',
'HLSFragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
],
'ContainerFormat' => '',
'DiscontinuityMode' => '',
'DisplayFragmentTimestamp' => '',
'Expires' => 0,
'MaxMediaPlaylistFragmentResults' => 0
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'StreamName' => '',
'StreamARN' => '',
'PlaybackMode' => '',
'HLSFragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
],
'ContainerFormat' => '',
'DiscontinuityMode' => '',
'DisplayFragmentTimestamp' => '',
'Expires' => 0,
'MaxMediaPlaylistFragmentResults' => 0
]));
$request->setRequestUrl('{{baseUrl}}/getHLSStreamingSessionURL');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/getHLSStreamingSessionURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getHLSStreamingSessionURL' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/getHLSStreamingSessionURL", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getHLSStreamingSessionURL"
payload = {
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/getHLSStreamingSessionURL"
payload <- "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getHLSStreamingSessionURL")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/getHLSStreamingSessionURL') do |req|
req.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"PlaybackMode\": \"\",\n \"HLSFragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n },\n \"ContainerFormat\": \"\",\n \"DiscontinuityMode\": \"\",\n \"DisplayFragmentTimestamp\": \"\",\n \"Expires\": 0,\n \"MaxMediaPlaylistFragmentResults\": 0\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getHLSStreamingSessionURL";
let payload = json!({
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": json!({
"FragmentSelectorType": "",
"TimestampRange": ""
}),
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/getHLSStreamingSessionURL \
--header 'content-type: application/json' \
--data '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
}'echo '{
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
},
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
}' | \
http POST {{baseUrl}}/getHLSStreamingSessionURL \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "StreamName": "",\n "StreamARN": "",\n "PlaybackMode": "",\n "HLSFragmentSelector": {\n "FragmentSelectorType": "",\n "TimestampRange": ""\n },\n "ContainerFormat": "",\n "DiscontinuityMode": "",\n "DisplayFragmentTimestamp": "",\n "Expires": 0,\n "MaxMediaPlaylistFragmentResults": 0\n}' \
--output-document \
- {{baseUrl}}/getHLSStreamingSessionURLimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"StreamName": "",
"StreamARN": "",
"PlaybackMode": "",
"HLSFragmentSelector": [
"FragmentSelectorType": "",
"TimestampRange": ""
],
"ContainerFormat": "",
"DiscontinuityMode": "",
"DisplayFragmentTimestamp": "",
"Expires": 0,
"MaxMediaPlaylistFragmentResults": 0
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getHLSStreamingSessionURL")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
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
GetImages
{{baseUrl}}/getImages
BODY json
{
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": {},
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getImages");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/getImages" {:content-type :json
:form-params {:StreamName ""
:StreamARN ""
:ImageSelectorType ""
:StartTimestamp ""
:EndTimestamp ""
:SamplingInterval 0
:Format ""
:FormatConfig {}
:WidthPixels 0
:HeightPixels 0
:MaxResults 0
:NextToken ""}})require "http/client"
url = "{{baseUrl}}/getImages"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/getImages"),
Content = new StringContent("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getImages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getImages"
payload := strings.NewReader("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/getImages HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 256
{
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": {},
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getImages")
.setHeader("content-type", "application/json")
.setBody("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getImages"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/getImages")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/getImages")
.header("content-type", "application/json")
.body("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}")
.asString(); const data = JSON.stringify({
StreamName: '',
StreamARN: '',
ImageSelectorType: '',
StartTimestamp: '',
EndTimestamp: '',
SamplingInterval: 0,
Format: '',
FormatConfig: {},
WidthPixels: 0,
HeightPixels: 0,
MaxResults: 0,
NextToken: ''
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/getImages');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/getImages',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
ImageSelectorType: '',
StartTimestamp: '',
EndTimestamp: '',
SamplingInterval: 0,
Format: '',
FormatConfig: {},
WidthPixels: 0,
HeightPixels: 0,
MaxResults: 0,
NextToken: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getImages';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","ImageSelectorType":"","StartTimestamp":"","EndTimestamp":"","SamplingInterval":0,"Format":"","FormatConfig":{},"WidthPixels":0,"HeightPixels":0,"MaxResults":0,"NextToken":""}'
};
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}}/getImages',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "StreamName": "",\n "StreamARN": "",\n "ImageSelectorType": "",\n "StartTimestamp": "",\n "EndTimestamp": "",\n "SamplingInterval": 0,\n "Format": "",\n "FormatConfig": {},\n "WidthPixels": 0,\n "HeightPixels": 0,\n "MaxResults": 0,\n "NextToken": ""\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}")
val request = Request.Builder()
.url("{{baseUrl}}/getImages")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/getImages',
headers: {
'content-type': 'application/json'
}
};
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.write(JSON.stringify({
StreamName: '',
StreamARN: '',
ImageSelectorType: '',
StartTimestamp: '',
EndTimestamp: '',
SamplingInterval: 0,
Format: '',
FormatConfig: {},
WidthPixels: 0,
HeightPixels: 0,
MaxResults: 0,
NextToken: ''
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/getImages',
headers: {'content-type': 'application/json'},
body: {
StreamName: '',
StreamARN: '',
ImageSelectorType: '',
StartTimestamp: '',
EndTimestamp: '',
SamplingInterval: 0,
Format: '',
FormatConfig: {},
WidthPixels: 0,
HeightPixels: 0,
MaxResults: 0,
NextToken: ''
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/getImages');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
StreamName: '',
StreamARN: '',
ImageSelectorType: '',
StartTimestamp: '',
EndTimestamp: '',
SamplingInterval: 0,
Format: '',
FormatConfig: {},
WidthPixels: 0,
HeightPixels: 0,
MaxResults: 0,
NextToken: ''
});
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}}/getImages',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
ImageSelectorType: '',
StartTimestamp: '',
EndTimestamp: '',
SamplingInterval: 0,
Format: '',
FormatConfig: {},
WidthPixels: 0,
HeightPixels: 0,
MaxResults: 0,
NextToken: ''
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getImages';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","ImageSelectorType":"","StartTimestamp":"","EndTimestamp":"","SamplingInterval":0,"Format":"","FormatConfig":{},"WidthPixels":0,"HeightPixels":0,"MaxResults":0,"NextToken":""}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StreamName": @"",
@"StreamARN": @"",
@"ImageSelectorType": @"",
@"StartTimestamp": @"",
@"EndTimestamp": @"",
@"SamplingInterval": @0,
@"Format": @"",
@"FormatConfig": @{ },
@"WidthPixels": @0,
@"HeightPixels": @0,
@"MaxResults": @0,
@"NextToken": @"" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getImages"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
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}}/getImages" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getImages",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'StreamName' => '',
'StreamARN' => '',
'ImageSelectorType' => '',
'StartTimestamp' => '',
'EndTimestamp' => '',
'SamplingInterval' => 0,
'Format' => '',
'FormatConfig' => [
],
'WidthPixels' => 0,
'HeightPixels' => 0,
'MaxResults' => 0,
'NextToken' => ''
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/getImages', [
'body' => '{
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": {},
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/getImages');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'StreamName' => '',
'StreamARN' => '',
'ImageSelectorType' => '',
'StartTimestamp' => '',
'EndTimestamp' => '',
'SamplingInterval' => 0,
'Format' => '',
'FormatConfig' => [
],
'WidthPixels' => 0,
'HeightPixels' => 0,
'MaxResults' => 0,
'NextToken' => ''
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'StreamName' => '',
'StreamARN' => '',
'ImageSelectorType' => '',
'StartTimestamp' => '',
'EndTimestamp' => '',
'SamplingInterval' => 0,
'Format' => '',
'FormatConfig' => [
],
'WidthPixels' => 0,
'HeightPixels' => 0,
'MaxResults' => 0,
'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/getImages');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/getImages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": {},
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getImages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": {},
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/getImages", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getImages"
payload = {
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": {},
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/getImages"
payload <- "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getImages")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/getImages') do |req|
req.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"ImageSelectorType\": \"\",\n \"StartTimestamp\": \"\",\n \"EndTimestamp\": \"\",\n \"SamplingInterval\": 0,\n \"Format\": \"\",\n \"FormatConfig\": {},\n \"WidthPixels\": 0,\n \"HeightPixels\": 0,\n \"MaxResults\": 0,\n \"NextToken\": \"\"\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getImages";
let payload = json!({
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": json!({}),
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/getImages \
--header 'content-type: application/json' \
--data '{
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": {},
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
}'echo '{
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": {},
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
}' | \
http POST {{baseUrl}}/getImages \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "StreamName": "",\n "StreamARN": "",\n "ImageSelectorType": "",\n "StartTimestamp": "",\n "EndTimestamp": "",\n "SamplingInterval": 0,\n "Format": "",\n "FormatConfig": {},\n "WidthPixels": 0,\n "HeightPixels": 0,\n "MaxResults": 0,\n "NextToken": ""\n}' \
--output-document \
- {{baseUrl}}/getImagesimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"StreamName": "",
"StreamARN": "",
"ImageSelectorType": "",
"StartTimestamp": "",
"EndTimestamp": "",
"SamplingInterval": 0,
"Format": "",
"FormatConfig": [],
"WidthPixels": 0,
"HeightPixels": 0,
"MaxResults": 0,
"NextToken": ""
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getImages")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
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
GetMediaForFragmentList
{{baseUrl}}/getMediaForFragmentList
BODY json
{
"StreamName": "",
"StreamARN": "",
"Fragments": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getMediaForFragmentList");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/getMediaForFragmentList" {:content-type :json
:form-params {:StreamName ""
:StreamARN ""
:Fragments []}})require "http/client"
url = "{{baseUrl}}/getMediaForFragmentList"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/getMediaForFragmentList"),
Content = new StringContent("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getMediaForFragmentList");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getMediaForFragmentList"
payload := strings.NewReader("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/getMediaForFragmentList HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 60
{
"StreamName": "",
"StreamARN": "",
"Fragments": []
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getMediaForFragmentList")
.setHeader("content-type", "application/json")
.setBody("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getMediaForFragmentList"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/getMediaForFragmentList")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/getMediaForFragmentList")
.header("content-type", "application/json")
.body("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}")
.asString(); const data = JSON.stringify({
StreamName: '',
StreamARN: '',
Fragments: []
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/getMediaForFragmentList');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/getMediaForFragmentList',
headers: {'content-type': 'application/json'},
data: {StreamName: '', StreamARN: '', Fragments: []}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getMediaForFragmentList';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","Fragments":[]}'
};
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}}/getMediaForFragmentList',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "StreamName": "",\n "StreamARN": "",\n "Fragments": []\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}")
val request = Request.Builder()
.url("{{baseUrl}}/getMediaForFragmentList")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/getMediaForFragmentList',
headers: {
'content-type': 'application/json'
}
};
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.write(JSON.stringify({StreamName: '', StreamARN: '', Fragments: []}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/getMediaForFragmentList',
headers: {'content-type': 'application/json'},
body: {StreamName: '', StreamARN: '', Fragments: []},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/getMediaForFragmentList');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
StreamName: '',
StreamARN: '',
Fragments: []
});
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}}/getMediaForFragmentList',
headers: {'content-type': 'application/json'},
data: {StreamName: '', StreamARN: '', Fragments: []}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getMediaForFragmentList';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","Fragments":[]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StreamName": @"",
@"StreamARN": @"",
@"Fragments": @[ ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getMediaForFragmentList"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
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}}/getMediaForFragmentList" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getMediaForFragmentList",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'StreamName' => '',
'StreamARN' => '',
'Fragments' => [
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/getMediaForFragmentList', [
'body' => '{
"StreamName": "",
"StreamARN": "",
"Fragments": []
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/getMediaForFragmentList');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'StreamName' => '',
'StreamARN' => '',
'Fragments' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'StreamName' => '',
'StreamARN' => '',
'Fragments' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/getMediaForFragmentList');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/getMediaForFragmentList' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"Fragments": []
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/getMediaForFragmentList' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"Fragments": []
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/getMediaForFragmentList", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getMediaForFragmentList"
payload = {
"StreamName": "",
"StreamARN": "",
"Fragments": []
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/getMediaForFragmentList"
payload <- "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getMediaForFragmentList")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/getMediaForFragmentList') do |req|
req.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"Fragments\": []\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getMediaForFragmentList";
let payload = json!({
"StreamName": "",
"StreamARN": "",
"Fragments": ()
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/getMediaForFragmentList \
--header 'content-type: application/json' \
--data '{
"StreamName": "",
"StreamARN": "",
"Fragments": []
}'echo '{
"StreamName": "",
"StreamARN": "",
"Fragments": []
}' | \
http POST {{baseUrl}}/getMediaForFragmentList \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "StreamName": "",\n "StreamARN": "",\n "Fragments": []\n}' \
--output-document \
- {{baseUrl}}/getMediaForFragmentListimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"StreamName": "",
"StreamARN": "",
"Fragments": []
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getMediaForFragmentList")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
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
ListFragments
{{baseUrl}}/listFragments
BODY json
{
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listFragments");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/listFragments" {:content-type :json
:form-params {:StreamName ""
:StreamARN ""
:MaxResults 0
:NextToken ""
:FragmentSelector {:FragmentSelectorType ""
:TimestampRange ""}}})require "http/client"
url = "{{baseUrl}}/listFragments"
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/listFragments"),
Content = new StringContent("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/listFragments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/listFragments"
payload := strings.NewReader("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/listFragments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 165
{
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/listFragments")
.setHeader("content-type", "application/json")
.setBody("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/listFragments"))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/listFragments")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/listFragments")
.header("content-type", "application/json")
.body("{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
.asString(); const data = JSON.stringify({
StreamName: '',
StreamARN: '',
MaxResults: 0,
NextToken: '',
FragmentSelector: {
FragmentSelectorType: '',
TimestampRange: ''
}
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/listFragments');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/listFragments',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
MaxResults: 0,
NextToken: '',
FragmentSelector: {FragmentSelectorType: '', TimestampRange: ''}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/listFragments';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","MaxResults":0,"NextToken":"","FragmentSelector":{"FragmentSelectorType":"","TimestampRange":""}}'
};
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}}/listFragments',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "StreamName": "",\n "StreamARN": "",\n "MaxResults": 0,\n "NextToken": "",\n "FragmentSelector": {\n "FragmentSelectorType": "",\n "TimestampRange": ""\n }\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}")
val request = Request.Builder()
.url("{{baseUrl}}/listFragments")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/listFragments',
headers: {
'content-type': 'application/json'
}
};
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.write(JSON.stringify({
StreamName: '',
StreamARN: '',
MaxResults: 0,
NextToken: '',
FragmentSelector: {FragmentSelectorType: '', TimestampRange: ''}
}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/listFragments',
headers: {'content-type': 'application/json'},
body: {
StreamName: '',
StreamARN: '',
MaxResults: 0,
NextToken: '',
FragmentSelector: {FragmentSelectorType: '', TimestampRange: ''}
},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/listFragments');
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
StreamName: '',
StreamARN: '',
MaxResults: 0,
NextToken: '',
FragmentSelector: {
FragmentSelectorType: '',
TimestampRange: ''
}
});
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}}/listFragments',
headers: {'content-type': 'application/json'},
data: {
StreamName: '',
StreamARN: '',
MaxResults: 0,
NextToken: '',
FragmentSelector: {FragmentSelectorType: '', TimestampRange: ''}
}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/listFragments';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"StreamName":"","StreamARN":"","MaxResults":0,"NextToken":"","FragmentSelector":{"FragmentSelectorType":"","TimestampRange":""}}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"StreamName": @"",
@"StreamARN": @"",
@"MaxResults": @0,
@"NextToken": @"",
@"FragmentSelector": @{ @"FragmentSelectorType": @"", @"TimestampRange": @"" } };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listFragments"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
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}}/listFragments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/listFragments",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'StreamName' => '',
'StreamARN' => '',
'MaxResults' => 0,
'NextToken' => '',
'FragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/listFragments', [
'body' => '{
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/listFragments');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'StreamName' => '',
'StreamARN' => '',
'MaxResults' => 0,
'NextToken' => '',
'FragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'StreamName' => '',
'StreamARN' => '',
'MaxResults' => 0,
'NextToken' => '',
'FragmentSelector' => [
'FragmentSelectorType' => '',
'TimestampRange' => ''
]
]));
$request->setRequestUrl('{{baseUrl}}/listFragments');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/listFragments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/listFragments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/listFragments", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/listFragments"
payload = {
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/listFragments"
payload <- "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/listFragments")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/listFragments') do |req|
req.body = "{\n \"StreamName\": \"\",\n \"StreamARN\": \"\",\n \"MaxResults\": 0,\n \"NextToken\": \"\",\n \"FragmentSelector\": {\n \"FragmentSelectorType\": \"\",\n \"TimestampRange\": \"\"\n }\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/listFragments";
let payload = json!({
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": json!({
"FragmentSelectorType": "",
"TimestampRange": ""
})
});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/listFragments \
--header 'content-type: application/json' \
--data '{
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}'echo '{
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": {
"FragmentSelectorType": "",
"TimestampRange": ""
}
}' | \
http POST {{baseUrl}}/listFragments \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "StreamName": "",\n "StreamARN": "",\n "MaxResults": 0,\n "NextToken": "",\n "FragmentSelector": {\n "FragmentSelectorType": "",\n "TimestampRange": ""\n }\n}' \
--output-document \
- {{baseUrl}}/listFragmentsimport Foundation
let headers = ["content-type": "application/json"]
let parameters = [
"StreamName": "",
"StreamARN": "",
"MaxResults": 0,
"NextToken": "",
"FragmentSelector": [
"FragmentSelectorType": "",
"TimestampRange": ""
]
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listFragments")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
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()