Radio & Music Services
GET
Broadcasts by PID
{{baseUrl}}/broadcasts/:pid
HEADERS
X-API-Key
QUERY PARAMS
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/broadcasts/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/broadcasts/:pid" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/broadcasts/:pid"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/broadcasts/:pid"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/broadcasts/:pid");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/broadcasts/:pid"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/broadcasts/:pid HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/broadcasts/:pid")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/broadcasts/:pid"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/broadcasts/:pid")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/broadcasts/:pid")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/broadcasts/:pid');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/broadcasts/:pid',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/broadcasts/:pid';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/broadcasts/:pid',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/broadcasts/:pid")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/broadcasts/:pid',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/broadcasts/:pid',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/broadcasts/:pid');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/broadcasts/:pid',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/broadcasts/:pid';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/broadcasts/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/broadcasts/:pid" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/broadcasts/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/broadcasts/:pid', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/broadcasts/:pid');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/broadcasts/:pid');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/broadcasts/:pid' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/broadcasts/:pid' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/broadcasts/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/broadcasts/:pid"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/broadcasts/:pid"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/broadcasts/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/broadcasts/:pid') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/broadcasts/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/broadcasts/:pid \
--header 'x-api-key: 'http GET {{baseUrl}}/broadcasts/:pid \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/broadcasts/:pidimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/broadcasts/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Broadcasts
{{baseUrl}}/broadcasts
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/broadcasts");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/broadcasts" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/broadcasts"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/broadcasts"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/broadcasts");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/broadcasts"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/broadcasts HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/broadcasts")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/broadcasts"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/broadcasts")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/broadcasts")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/broadcasts');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/broadcasts',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/broadcasts';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/broadcasts',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/broadcasts")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/broadcasts',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/broadcasts',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/broadcasts');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/broadcasts',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/broadcasts';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/broadcasts"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/broadcasts" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/broadcasts",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/broadcasts', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/broadcasts');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/broadcasts');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/broadcasts' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/broadcasts' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/broadcasts", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/broadcasts"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/broadcasts"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/broadcasts")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/broadcasts') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/broadcasts";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/broadcasts \
--header 'x-api-key: 'http GET {{baseUrl}}/broadcasts \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/broadcastsimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/broadcasts")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Latest Broadcasts
{{baseUrl}}/broadcasts/latest
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/broadcasts/latest");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/broadcasts/latest" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/broadcasts/latest"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/broadcasts/latest"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/broadcasts/latest");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/broadcasts/latest"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/broadcasts/latest HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/broadcasts/latest")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/broadcasts/latest"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/broadcasts/latest")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/broadcasts/latest")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/broadcasts/latest');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/broadcasts/latest',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/broadcasts/latest';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/broadcasts/latest',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/broadcasts/latest")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/broadcasts/latest',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/broadcasts/latest',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/broadcasts/latest');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/broadcasts/latest',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/broadcasts/latest';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/broadcasts/latest"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/broadcasts/latest" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/broadcasts/latest",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/broadcasts/latest', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/broadcasts/latest');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/broadcasts/latest');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/broadcasts/latest' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/broadcasts/latest' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/broadcasts/latest", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/broadcasts/latest"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/broadcasts/latest"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/broadcasts/latest")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/broadcasts/latest') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/broadcasts/latest";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/broadcasts/latest \
--header 'x-api-key: 'http GET {{baseUrl}}/broadcasts/latest \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/broadcasts/latestimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/broadcasts/latest")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Category by ID
{{baseUrl}}/categories/:id
HEADERS
X-API-Key
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/categories/:id" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/categories/:id"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/categories/:id"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/categories/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/categories/:id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/categories/:id HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/categories/:id")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/categories/:id"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/categories/:id")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/categories/:id")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/categories/:id');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/categories/:id',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/categories/:id';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/categories/:id',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/categories/:id")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/categories/:id',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/categories/:id',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/categories/:id');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/categories/:id',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/categories/:id';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/categories/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/categories/:id" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/categories/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/categories/:id', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/categories/:id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/categories/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories/:id' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories/:id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/categories/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/categories/:id"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/categories/:id"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/categories/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/categories/:id') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/categories/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/categories/:id \
--header 'x-api-key: 'http GET {{baseUrl}}/categories/:id \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/categories/:idimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/categories/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List of categories
{{baseUrl}}/categories
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/categories" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/categories"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/categories"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/categories");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/categories"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/categories HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/categories")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/categories"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/categories")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/categories")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/categories');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/categories',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/categories';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/categories',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/categories")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/categories',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/categories',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/categories');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/categories',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/categories';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/categories"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/categories" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/categories",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/categories', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/categories');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/categories');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/categories", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/categories"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/categories"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/categories")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/categories') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/categories";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/categories \
--header 'x-api-key: 'http GET {{baseUrl}}/categories \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/categoriesimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/categories")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Collection Members
{{baseUrl}}/collections/:pid/members
HEADERS
X-API-Key
QUERY PARAMS
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/collections/:pid/members");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/collections/:pid/members" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/collections/:pid/members"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/collections/:pid/members"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/collections/:pid/members");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/collections/:pid/members"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/collections/:pid/members HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/collections/:pid/members")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/collections/:pid/members"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/collections/:pid/members")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/collections/:pid/members")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/collections/:pid/members');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/collections/:pid/members',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/collections/:pid/members';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/collections/:pid/members',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/collections/:pid/members")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/collections/:pid/members',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/collections/:pid/members',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/collections/:pid/members');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/collections/:pid/members',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/collections/:pid/members';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/collections/:pid/members"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/collections/:pid/members" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/collections/:pid/members",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/collections/:pid/members', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/collections/:pid/members');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/collections/:pid/members');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/collections/:pid/members' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/collections/:pid/members' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/collections/:pid/members", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/collections/:pid/members"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/collections/:pid/members"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/collections/:pid/members")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/collections/:pid/members') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/collections/:pid/members";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/collections/:pid/members \
--header 'x-api-key: 'http GET {{baseUrl}}/collections/:pid/members \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/collections/:pid/membersimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/collections/:pid/members")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Homepage Experience
{{baseUrl}}/experience/homepage
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/experience/homepage");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/experience/homepage" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/experience/homepage"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/experience/homepage"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/experience/homepage");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/experience/homepage"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/experience/homepage HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/experience/homepage")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/experience/homepage"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/experience/homepage")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/experience/homepage")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/experience/homepage');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/experience/homepage',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/experience/homepage';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/experience/homepage',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/experience/homepage")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/experience/homepage',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/experience/homepage',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/experience/homepage');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/experience/homepage',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/experience/homepage';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/experience/homepage"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/experience/homepage" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/experience/homepage",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/experience/homepage', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/experience/homepage');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/experience/homepage');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/experience/homepage' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/experience/homepage' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/experience/homepage", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/experience/homepage"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/experience/homepage"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/experience/homepage")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/experience/homepage') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/experience/homepage";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/experience/homepage \
--header 'x-api-key: 'http GET {{baseUrl}}/experience/homepage \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/experience/homepageimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/experience/homepage")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Favourite Track or Clip (GET)
{{baseUrl}}/my/music/favourites/:type/:id
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/favourites/:type/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/favourites/:type/:id" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/favourites/:type/:id"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/favourites/:type/:id"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/favourites/:type/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/favourites/:type/:id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/favourites/:type/:id HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/favourites/:type/:id")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/favourites/:type/:id"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type/:id")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/favourites/:type/:id")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/favourites/:type/:id');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/favourites/:type/:id';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/favourites/:type/:id',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type/:id")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/favourites/:type/:id',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/favourites/:type/:id');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/favourites/:type/:id';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/favourites/:type/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/favourites/:type/:id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/favourites/:type/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/favourites/:type/:id', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/favourites/:type/:id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/favourites/:type/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/favourites/:type/:id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/favourites/:type/:id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/favourites/:type/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/favourites/:type/:id"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/favourites/:type/:id"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/favourites/:type/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/favourites/:type/:id') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/favourites/:type/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/music/favourites/:type/:id \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/music/favourites/:type/:id \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/favourites/:type/:idimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/favourites/:type/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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
Favourite Track or Clip (POST)
{{baseUrl}}/my/music/favourites/:type/:id
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/favourites/:type/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/music/favourites/:type/:id" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/favourites/:type/:id"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/music/favourites/:type/:id"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/favourites/:type/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/favourites/:type/:id"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/music/favourites/:type/:id HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/music/favourites/:type/:id")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/favourites/:type/:id"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type/:id")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/music/favourites/:type/:id")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/music/favourites/:type/:id');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/favourites/:type/:id';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/favourites/:type/:id',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type/:id")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/favourites/:type/:id',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/music/favourites/:type/:id');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/favourites/:type/:id';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/favourites/:type/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/favourites/:type/:id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/favourites/:type/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/music/favourites/:type/:id', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/favourites/:type/:id');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/favourites/:type/:id');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/favourites/:type/:id' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/favourites/:type/:id' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/music/favourites/:type/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/favourites/:type/:id"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/favourites/:type/:id"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/favourites/:type/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/music/favourites/:type/:id') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/favourites/:type/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/music/favourites/:type/:id \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/music/favourites/:type/:id \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/favourites/:type/:idimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/favourites/:type/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Favourite Track or Clip (PUT)
{{baseUrl}}/my/music/favourites/:type/:id
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/favourites/:type/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/my/music/favourites/:type/:id" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/favourites/:type/:id"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/my/music/favourites/:type/:id"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/favourites/:type/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/favourites/:type/:id"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/my/music/favourites/:type/:id HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/music/favourites/:type/:id")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/favourites/:type/:id"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type/:id")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/my/music/favourites/:type/:id")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/my/music/favourites/:type/:id');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/favourites/:type/:id';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/favourites/:type/:id',
method: 'PUT',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type/:id")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/favourites/:type/:id',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/my/music/favourites/:type/:id');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/favourites/:type/:id';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/favourites/:type/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/favourites/:type/:id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/favourites/:type/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/my/music/favourites/:type/:id', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/favourites/:type/:id');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/favourites/:type/:id');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/favourites/:type/:id' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/favourites/:type/:id' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("PUT", "/baseUrl/my/music/favourites/:type/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/favourites/:type/:id"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/favourites/:type/:id"
response <- VERB("PUT", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/favourites/:type/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/my/music/favourites/:type/:id') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/favourites/:type/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/my/music/favourites/:type/:id \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http PUT {{baseUrl}}/my/music/favourites/:type/:id \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method PUT \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/favourites/:type/:idimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/favourites/:type/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Favourite Track or Clip
{{baseUrl}}/my/music/favourites/:type/:id
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/favourites/:type/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/my/music/favourites/:type/:id" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/favourites/:type/:id"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/my/music/favourites/:type/:id"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/favourites/:type/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/favourites/:type/:id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/my/music/favourites/:type/:id HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/music/favourites/:type/:id")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/favourites/:type/:id"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type/:id")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/my/music/favourites/:type/:id")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/my/music/favourites/:type/:id');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/favourites/:type/:id';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/favourites/:type/:id',
method: 'DELETE',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type/:id")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/favourites/:type/:id',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/my/music/favourites/:type/:id');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/favourites/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/favourites/:type/:id';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/favourites/:type/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/favourites/:type/:id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/favourites/:type/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/my/music/favourites/:type/:id', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/favourites/:type/:id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/favourites/:type/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/favourites/:type/:id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/favourites/:type/:id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("DELETE", "/baseUrl/my/music/favourites/:type/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/favourites/:type/:id"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/favourites/:type/:id"
response <- VERB("DELETE", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/favourites/:type/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/my/music/favourites/:type/:id') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/favourites/:type/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/my/music/favourites/:type/:id \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http DELETE {{baseUrl}}/my/music/favourites/:type/:id \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method DELETE \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/favourites/:type/:idimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/favourites/:type/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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
Favourite Tracks or Clips (POST)
{{baseUrl}}/my/music/favourites
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/favourites");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/music/favourites" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/favourites"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/music/favourites"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/favourites");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/favourites"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/music/favourites HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/music/favourites")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/favourites"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/favourites")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/music/favourites")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/music/favourites');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/favourites';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/favourites',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/favourites")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/favourites',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/music/favourites');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/music/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/favourites';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/favourites"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/favourites" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/favourites",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/music/favourites', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/favourites');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/favourites');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/favourites' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/favourites' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/music/favourites", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/favourites"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/favourites"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/favourites")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/music/favourites') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/favourites";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/music/favourites \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/music/favourites \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/favouritesimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/favourites")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Favourite Tracks or Clips (PUT)
{{baseUrl}}/my/music/favourites
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/favourites");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/my/music/favourites" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/favourites"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/my/music/favourites"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/favourites");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/favourites"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/my/music/favourites HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/music/favourites")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/favourites"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/favourites")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/my/music/favourites")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/my/music/favourites');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/favourites';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/favourites',
method: 'PUT',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/favourites")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/favourites',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/my/music/favourites');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/favourites';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/favourites"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/favourites" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/favourites",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/my/music/favourites', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/favourites');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/favourites');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/favourites' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/favourites' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("PUT", "/baseUrl/my/music/favourites", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/favourites"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/favourites"
response <- VERB("PUT", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/favourites")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/my/music/favourites') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/favourites";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/my/music/favourites \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http PUT {{baseUrl}}/my/music/favourites \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method PUT \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/favouritesimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/favourites")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Favourite Tracks or Clips by Type
{{baseUrl}}/my/music/favourites/:type
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/favourites/:type");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/favourites/:type" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/favourites/:type"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/favourites/:type"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/favourites/:type");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/favourites/:type"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/favourites/:type HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/favourites/:type")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/favourites/:type"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/favourites/:type")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/favourites/:type');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/favourites/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/favourites/:type';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/favourites/:type',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/favourites/:type")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/favourites/:type',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/favourites/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/favourites/:type');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/favourites/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/favourites/:type';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/favourites/:type"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/favourites/:type" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/favourites/:type",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/favourites/:type', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/favourites/:type');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/favourites/:type');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/favourites/:type' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/favourites/:type' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/favourites/:type", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/favourites/:type"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/favourites/:type"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/favourites/:type")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/favourites/:type') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/favourites/:type";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/music/favourites/:type \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/music/favourites/:type \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/favourites/:typeimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/favourites/:type")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Favourite Tracks or Clips
{{baseUrl}}/my/music/favourites
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/favourites");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/favourites" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/favourites"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/favourites"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/favourites");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/favourites"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/favourites HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/favourites")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/favourites"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/favourites")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/favourites")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/favourites');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/favourites';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/favourites',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/favourites")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/favourites',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/favourites');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/favourites';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/favourites"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/favourites" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/favourites",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/favourites', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/favourites');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/favourites');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/favourites' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/favourites' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/favourites", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/favourites"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/favourites"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/favourites")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/favourites') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/favourites";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/music/favourites \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/music/favourites \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/favouritesimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/favourites")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Followed Network, Category, Artist, Playlist and Genre (GET)
{{baseUrl}}/my/music/follows/:type/:id
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/follows/:type/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/follows/:type/:id" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/follows/:type/:id"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/follows/:type/:id"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/follows/:type/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/follows/:type/:id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/follows/:type/:id HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/follows/:type/:id")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/follows/:type/:id"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type/:id")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/follows/:type/:id")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/follows/:type/:id');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/follows/:type/:id';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/follows/:type/:id',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type/:id")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/follows/:type/:id',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/follows/:type/:id');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/follows/:type/:id';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/follows/:type/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/follows/:type/:id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/follows/:type/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/follows/:type/:id', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/follows/:type/:id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/follows/:type/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/follows/:type/:id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/follows/:type/:id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/follows/:type/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/follows/:type/:id"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/follows/:type/:id"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/follows/:type/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/follows/:type/:id') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/follows/:type/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/music/follows/:type/:id \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/music/follows/:type/:id \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/follows/:type/:idimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/follows/:type/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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
Followed Network, Category, Artist, Playlist and Genre (POST)
{{baseUrl}}/my/music/follows/:type/:id
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/follows/:type/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/music/follows/:type/:id" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/follows/:type/:id"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/music/follows/:type/:id"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/follows/:type/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/follows/:type/:id"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/music/follows/:type/:id HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/music/follows/:type/:id")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/follows/:type/:id"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type/:id")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/music/follows/:type/:id")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/music/follows/:type/:id');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/follows/:type/:id';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/follows/:type/:id',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type/:id")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/follows/:type/:id',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/music/follows/:type/:id');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/follows/:type/:id';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/follows/:type/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/follows/:type/:id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/follows/:type/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/music/follows/:type/:id', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/follows/:type/:id');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/follows/:type/:id');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/follows/:type/:id' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/follows/:type/:id' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/music/follows/:type/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/follows/:type/:id"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/follows/:type/:id"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/follows/:type/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/music/follows/:type/:id') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/follows/:type/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/music/follows/:type/:id \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/music/follows/:type/:id \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/follows/:type/:idimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/follows/:type/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Followed Network, Category, Artist, Playlist and Genre (PUT)
{{baseUrl}}/my/music/follows/:type/:id
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/follows/:type/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/my/music/follows/:type/:id" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/follows/:type/:id"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/my/music/follows/:type/:id"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/follows/:type/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/follows/:type/:id"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/my/music/follows/:type/:id HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/music/follows/:type/:id")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/follows/:type/:id"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type/:id")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/my/music/follows/:type/:id")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/my/music/follows/:type/:id');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/follows/:type/:id';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/follows/:type/:id',
method: 'PUT',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type/:id")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/follows/:type/:id',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/my/music/follows/:type/:id');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/follows/:type/:id';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/follows/:type/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/follows/:type/:id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/follows/:type/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/my/music/follows/:type/:id', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/follows/:type/:id');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/follows/:type/:id');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/follows/:type/:id' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/follows/:type/:id' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("PUT", "/baseUrl/my/music/follows/:type/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/follows/:type/:id"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/follows/:type/:id"
response <- VERB("PUT", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/follows/:type/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/my/music/follows/:type/:id') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/follows/:type/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/my/music/follows/:type/:id \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http PUT {{baseUrl}}/my/music/follows/:type/:id \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method PUT \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/follows/:type/:idimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/follows/:type/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Followed Network, Category, Artist, Playlist and Genre
{{baseUrl}}/my/music/follows/:type/:id
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/follows/:type/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/my/music/follows/:type/:id" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/follows/:type/:id"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/my/music/follows/:type/:id"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/follows/:type/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/follows/:type/:id"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/my/music/follows/:type/:id HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/music/follows/:type/:id")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/follows/:type/:id"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type/:id")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/my/music/follows/:type/:id")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/my/music/follows/:type/:id');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/follows/:type/:id';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/follows/:type/:id',
method: 'DELETE',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type/:id")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/follows/:type/:id',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/my/music/follows/:type/:id');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/follows/:type/:id',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/follows/:type/:id';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/follows/:type/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/follows/:type/:id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/follows/:type/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/my/music/follows/:type/:id', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/follows/:type/:id');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/follows/:type/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/follows/:type/:id' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/follows/:type/:id' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("DELETE", "/baseUrl/my/music/follows/:type/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/follows/:type/:id"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/follows/:type/:id"
response <- VERB("DELETE", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/follows/:type/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/my/music/follows/:type/:id') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/follows/:type/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/my/music/follows/:type/:id \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http DELETE {{baseUrl}}/my/music/follows/:type/:id \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method DELETE \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/follows/:type/:idimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/follows/:type/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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
Followed Networks, Categories, Artists, Playlists and Genres (POST)
{{baseUrl}}/my/music/follows
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/music/follows" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/music/follows"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/follows");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/follows"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/music/follows HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/music/follows")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/follows"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/follows")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/music/follows")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/music/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/follows';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/follows',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/follows")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/follows',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/music/follows');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/music/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/follows';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/music/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/follows');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/follows');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/follows' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/follows' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/music/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/follows"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/follows"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/music/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/music/follows \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/music/follows \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/followsimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Followed Networks, Categories, Artists, Playlists and Genres (PUT)
{{baseUrl}}/my/music/follows
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/my/music/follows" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/my/music/follows"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/follows");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/follows"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/my/music/follows HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/music/follows")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/follows"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/follows")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/my/music/follows")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/my/music/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/follows';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/follows',
method: 'PUT',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/follows")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/follows',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/my/music/follows');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/follows';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/my/music/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/follows');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/follows');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/follows' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/follows' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("PUT", "/baseUrl/my/music/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/follows"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/follows"
response <- VERB("PUT", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/my/music/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/my/music/follows \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http PUT {{baseUrl}}/my/music/follows \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method PUT \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/followsimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Followed Networks, Categories, Artists, Playlists and Genres by Type
{{baseUrl}}/my/music/follows/:type
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/follows/:type");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/follows/:type" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/follows/:type"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/follows/:type"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/follows/:type");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/follows/:type"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/follows/:type HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/follows/:type")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/follows/:type"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/follows/:type")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/follows/:type');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/follows/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/follows/:type';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/follows/:type',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/follows/:type")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/follows/:type',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/follows/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/follows/:type');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/follows/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/follows/:type';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/follows/:type"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/follows/:type" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/follows/:type",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/follows/:type', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/follows/:type');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/follows/:type');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/follows/:type' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/follows/:type' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/follows/:type", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/follows/:type"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/follows/:type"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/follows/:type")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/follows/:type') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/follows/:type";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/music/follows/:type \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/music/follows/:type \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/follows/:typeimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/follows/:type")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Followed Networks, Categories, Artists, Playlists and Genres
{{baseUrl}}/my/music/follows
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/follows" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/follows"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/follows");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/follows"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/follows HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/follows")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/follows"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/follows")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/follows")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/follows';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/follows',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/follows")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/follows',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/follows');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/follows';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/follows');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/follows');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/follows' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/follows' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/follows"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/follows"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/music/follows \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/music/follows \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/followsimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Popular Artists
{{baseUrl}}/music/popular/artists
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/music/popular/artists");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/music/popular/artists" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/music/popular/artists"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/music/popular/artists"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/music/popular/artists");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/music/popular/artists"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/music/popular/artists HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/music/popular/artists")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/music/popular/artists"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/music/popular/artists")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/music/popular/artists")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/music/popular/artists');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/artists',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/music/popular/artists';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/music/popular/artists',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/music/popular/artists")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/music/popular/artists',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/artists',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/music/popular/artists');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/artists',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/music/popular/artists';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/music/popular/artists"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/music/popular/artists" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/music/popular/artists",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/music/popular/artists', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/music/popular/artists');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/music/popular/artists');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/music/popular/artists' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/music/popular/artists' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/music/popular/artists", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/music/popular/artists"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/music/popular/artists"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/music/popular/artists")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/music/popular/artists') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/music/popular/artists";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/music/popular/artists \
--header 'x-api-key: 'http GET {{baseUrl}}/music/popular/artists \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/music/popular/artistsimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/music/popular/artists")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Popular Playlists
{{baseUrl}}/music/popular/playlists
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/music/popular/playlists");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/music/popular/playlists" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/music/popular/playlists"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/music/popular/playlists"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/music/popular/playlists");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/music/popular/playlists"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/music/popular/playlists HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/music/popular/playlists")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/music/popular/playlists"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/music/popular/playlists")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/music/popular/playlists")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/music/popular/playlists');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/playlists',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/music/popular/playlists';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/music/popular/playlists',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/music/popular/playlists")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/music/popular/playlists',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/playlists',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/music/popular/playlists');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/playlists',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/music/popular/playlists';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/music/popular/playlists"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/music/popular/playlists" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/music/popular/playlists",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/music/popular/playlists', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/music/popular/playlists');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/music/popular/playlists');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/music/popular/playlists' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/music/popular/playlists' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/music/popular/playlists", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/music/popular/playlists"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/music/popular/playlists"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/music/popular/playlists")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/music/popular/playlists') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/music/popular/playlists";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/music/popular/playlists \
--header 'x-api-key: 'http GET {{baseUrl}}/music/popular/playlists \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/music/popular/playlistsimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/music/popular/playlists")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Popular Tracks
{{baseUrl}}/music/popular/tracks
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/music/popular/tracks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/music/popular/tracks" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/music/popular/tracks"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/music/popular/tracks"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/music/popular/tracks");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/music/popular/tracks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/music/popular/tracks HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/music/popular/tracks")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/music/popular/tracks"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/music/popular/tracks")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/music/popular/tracks")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/music/popular/tracks');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/tracks',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/music/popular/tracks';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/music/popular/tracks',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/music/popular/tracks")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/music/popular/tracks',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/tracks',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/music/popular/tracks');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/tracks',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/music/popular/tracks';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/music/popular/tracks"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/music/popular/tracks" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/music/popular/tracks",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/music/popular/tracks', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/music/popular/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/music/popular/tracks');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/music/popular/tracks' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/music/popular/tracks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/music/popular/tracks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/music/popular/tracks"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/music/popular/tracks"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/music/popular/tracks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/music/popular/tracks') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/music/popular/tracks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/music/popular/tracks \
--header 'x-api-key: 'http GET {{baseUrl}}/music/popular/tracks \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/music/popular/tracksimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/music/popular/tracks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Single Artist Popularity
{{baseUrl}}/music/popular/artists/:id
HEADERS
X-API-Key
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/music/popular/artists/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/music/popular/artists/:id" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/music/popular/artists/:id"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/music/popular/artists/:id"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/music/popular/artists/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/music/popular/artists/:id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/music/popular/artists/:id HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/music/popular/artists/:id")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/music/popular/artists/:id"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/music/popular/artists/:id")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/music/popular/artists/:id")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/music/popular/artists/:id');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/artists/:id',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/music/popular/artists/:id';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/music/popular/artists/:id',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/music/popular/artists/:id")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/music/popular/artists/:id',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/artists/:id',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/music/popular/artists/:id');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/artists/:id',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/music/popular/artists/:id';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/music/popular/artists/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/music/popular/artists/:id" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/music/popular/artists/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/music/popular/artists/:id', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/music/popular/artists/:id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/music/popular/artists/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/music/popular/artists/:id' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/music/popular/artists/:id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/music/popular/artists/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/music/popular/artists/:id"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/music/popular/artists/:id"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/music/popular/artists/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/music/popular/artists/:id') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/music/popular/artists/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/music/popular/artists/:id \
--header 'x-api-key: 'http GET {{baseUrl}}/music/popular/artists/:id \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/music/popular/artists/:idimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/music/popular/artists/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Single Playlist Popularity
{{baseUrl}}/music/popular/playlists/:id
HEADERS
X-API-Key
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/music/popular/playlists/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/music/popular/playlists/:id" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/music/popular/playlists/:id"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/music/popular/playlists/:id"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/music/popular/playlists/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/music/popular/playlists/:id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/music/popular/playlists/:id HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/music/popular/playlists/:id")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/music/popular/playlists/:id"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/music/popular/playlists/:id")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/music/popular/playlists/:id")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/music/popular/playlists/:id');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/playlists/:id',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/music/popular/playlists/:id';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/music/popular/playlists/:id',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/music/popular/playlists/:id")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/music/popular/playlists/:id',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/playlists/:id',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/music/popular/playlists/:id');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/playlists/:id',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/music/popular/playlists/:id';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/music/popular/playlists/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/music/popular/playlists/:id" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/music/popular/playlists/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/music/popular/playlists/:id', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/music/popular/playlists/:id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/music/popular/playlists/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/music/popular/playlists/:id' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/music/popular/playlists/:id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/music/popular/playlists/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/music/popular/playlists/:id"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/music/popular/playlists/:id"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/music/popular/playlists/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/music/popular/playlists/:id') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/music/popular/playlists/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/music/popular/playlists/:id \
--header 'x-api-key: 'http GET {{baseUrl}}/music/popular/playlists/:id \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/music/popular/playlists/:idimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/music/popular/playlists/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Single Track Popularity
{{baseUrl}}/music/popular/tracks/:id
HEADERS
X-API-Key
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/music/popular/tracks/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/music/popular/tracks/:id" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/music/popular/tracks/:id"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/music/popular/tracks/:id"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/music/popular/tracks/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/music/popular/tracks/:id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/music/popular/tracks/:id HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/music/popular/tracks/:id")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/music/popular/tracks/:id"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/music/popular/tracks/:id")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/music/popular/tracks/:id")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/music/popular/tracks/:id');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/tracks/:id',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/music/popular/tracks/:id';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/music/popular/tracks/:id',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/music/popular/tracks/:id")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/music/popular/tracks/:id',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/tracks/:id',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/music/popular/tracks/:id');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/music/popular/tracks/:id',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/music/popular/tracks/:id';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/music/popular/tracks/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/music/popular/tracks/:id" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/music/popular/tracks/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/music/popular/tracks/:id', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/music/popular/tracks/:id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/music/popular/tracks/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/music/popular/tracks/:id' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/music/popular/tracks/:id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/music/popular/tracks/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/music/popular/tracks/:id"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/music/popular/tracks/:id"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/music/popular/tracks/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/music/popular/tracks/:id') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/music/popular/tracks/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/music/popular/tracks/:id \
--header 'x-api-key: 'http GET {{baseUrl}}/music/popular/tracks/:id \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/music/popular/tracks/:idimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/music/popular/tracks/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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
Music Export Jobs (POST)
{{baseUrl}}/my/music/exports/jobs
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
over16
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/exports/jobs?over16=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/music/exports/jobs" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}
:query-params {:over16 ""}})require "http/client"
url = "{{baseUrl}}/my/music/exports/jobs?over16="
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/music/exports/jobs?over16="),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/exports/jobs?over16=");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/exports/jobs?over16="
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/music/exports/jobs?over16= HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/music/exports/jobs?over16=")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/exports/jobs?over16="))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/exports/jobs?over16=")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/music/exports/jobs?over16=")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/music/exports/jobs?over16=');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/exports/jobs',
params: {over16: ''},
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/exports/jobs?over16=';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/exports/jobs?over16=',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/exports/jobs?over16=")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/exports/jobs?over16=',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/exports/jobs',
qs: {over16: ''},
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/music/exports/jobs');
req.query({
over16: ''
});
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/music/exports/jobs',
params: {over16: ''},
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/exports/jobs?over16=';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/exports/jobs?over16="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/exports/jobs?over16=" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/exports/jobs?over16=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/music/exports/jobs?over16=', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/exports/jobs');
$request->setMethod(HTTP_METH_POST);
$request->setQueryData([
'over16' => ''
]);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/exports/jobs');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
'over16' => ''
]));
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/exports/jobs?over16=' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/exports/jobs?over16=' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/music/exports/jobs?over16=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/exports/jobs"
querystring = {"over16":""}
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/exports/jobs"
queryString <- list(over16 = "")
response <- VERB("POST", url, query = queryString, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/exports/jobs?over16=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/music/exports/jobs') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
req.params['over16'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/exports/jobs";
let querystring = [
("over16", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/my/music/exports/jobs?over16=' \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST '{{baseUrl}}/my/music/exports/jobs?over16=' \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- '{{baseUrl}}/my/music/exports/jobs?over16='import Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/exports/jobs?over16=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Music Export Jobs
{{baseUrl}}/my/music/exports/jobs
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
over16
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/exports/jobs?over16=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/exports/jobs" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}
:query-params {:over16 ""}})require "http/client"
url = "{{baseUrl}}/my/music/exports/jobs?over16="
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/exports/jobs?over16="),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/exports/jobs?over16=");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/exports/jobs?over16="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/exports/jobs?over16= HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/exports/jobs?over16=")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/exports/jobs?over16="))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/exports/jobs?over16=")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/exports/jobs?over16=")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/exports/jobs?over16=');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/exports/jobs',
params: {over16: ''},
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/exports/jobs?over16=';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/exports/jobs?over16=',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/exports/jobs?over16=")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/exports/jobs?over16=',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/exports/jobs',
qs: {over16: ''},
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/exports/jobs');
req.query({
over16: ''
});
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/exports/jobs',
params: {over16: ''},
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/exports/jobs?over16=';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/exports/jobs?over16="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/exports/jobs?over16=" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/exports/jobs?over16=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/exports/jobs?over16=', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/exports/jobs');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'over16' => ''
]);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/exports/jobs');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'over16' => ''
]));
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/exports/jobs?over16=' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/exports/jobs?over16=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/exports/jobs?over16=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/exports/jobs"
querystring = {"over16":""}
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/exports/jobs"
queryString <- list(over16 = "")
response <- VERB("GET", url, query = queryString, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/exports/jobs?over16=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/exports/jobs') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
req.params['over16'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/exports/jobs";
let querystring = [
("over16", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/my/music/exports/jobs?over16=' \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET '{{baseUrl}}/my/music/exports/jobs?over16=' \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- '{{baseUrl}}/my/music/exports/jobs?over16='import Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/exports/jobs?over16=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Music Export Preferences (GET)
{{baseUrl}}/my/music/preferences/export
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/preferences/export");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/preferences/export" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/preferences/export"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/preferences/export"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/preferences/export");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/preferences/export"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/preferences/export HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/preferences/export")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/preferences/export"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/preferences/export")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/preferences/export');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/preferences/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/preferences/export';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/preferences/export',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/preferences/export',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/preferences/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/preferences/export');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/preferences/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/preferences/export';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/preferences/export"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/preferences/export" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/preferences/export",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/preferences/export', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/preferences/export');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/preferences/export');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/preferences/export' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/preferences/export' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/preferences/export", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/preferences/export"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/preferences/export"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/preferences/export")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/preferences/export') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/preferences/export";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/music/preferences/export \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/music/preferences/export \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/preferences/exportimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/preferences/export")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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
Music Export Preferences (POST)
{{baseUrl}}/my/music/preferences/export
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/preferences/export");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/music/preferences/export" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/preferences/export"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/music/preferences/export"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/preferences/export");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/preferences/export"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/music/preferences/export HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/music/preferences/export")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/preferences/export"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/music/preferences/export")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/music/preferences/export');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/preferences/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/preferences/export';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/preferences/export',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/preferences/export',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/preferences/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/music/preferences/export');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/music/preferences/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/preferences/export';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/preferences/export"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/preferences/export" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/preferences/export",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/music/preferences/export', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/preferences/export');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/preferences/export');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/preferences/export' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/preferences/export' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/music/preferences/export", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/preferences/export"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/preferences/export"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/preferences/export")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/music/preferences/export') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/preferences/export";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/music/preferences/export \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/music/preferences/export \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/preferences/exportimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/preferences/export")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Music Export Preferences
{{baseUrl}}/my/music/preferences/export
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/preferences/export");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/my/music/preferences/export" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/preferences/export"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/my/music/preferences/export"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/preferences/export");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/preferences/export"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/my/music/preferences/export HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/music/preferences/export")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/preferences/export"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/my/music/preferences/export")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/my/music/preferences/export');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/preferences/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/preferences/export';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/preferences/export',
method: 'DELETE',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/preferences/export',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/preferences/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/my/music/preferences/export');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/preferences/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/preferences/export';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/preferences/export"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/preferences/export" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/preferences/export",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/my/music/preferences/export', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/preferences/export');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/preferences/export');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/preferences/export' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/preferences/export' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("DELETE", "/baseUrl/my/music/preferences/export", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/preferences/export"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/preferences/export"
response <- VERB("DELETE", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/preferences/export")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/my/music/preferences/export') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/preferences/export";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/my/music/preferences/export \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http DELETE {{baseUrl}}/my/music/preferences/export \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method DELETE \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/preferences/exportimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/preferences/export")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Music Export Tracks
{{baseUrl}}/my/music/exports/tracks
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
over16
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/exports/tracks?over16=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/exports/tracks" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}
:query-params {:over16 ""}})require "http/client"
url = "{{baseUrl}}/my/music/exports/tracks?over16="
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/exports/tracks?over16="),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/exports/tracks?over16=");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/exports/tracks?over16="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/exports/tracks?over16= HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/exports/tracks?over16=")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/exports/tracks?over16="))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/exports/tracks?over16=")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/exports/tracks?over16=")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/exports/tracks?over16=');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/exports/tracks',
params: {over16: ''},
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/exports/tracks?over16=';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/exports/tracks?over16=',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/exports/tracks?over16=")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/exports/tracks?over16=',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/exports/tracks',
qs: {over16: ''},
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/exports/tracks');
req.query({
over16: ''
});
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/exports/tracks',
params: {over16: ''},
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/exports/tracks?over16=';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/exports/tracks?over16="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/exports/tracks?over16=" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/exports/tracks?over16=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/exports/tracks?over16=', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/exports/tracks');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'over16' => ''
]);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/exports/tracks');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'over16' => ''
]));
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/exports/tracks?over16=' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/exports/tracks?over16=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/exports/tracks?over16=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/exports/tracks"
querystring = {"over16":""}
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/exports/tracks"
queryString <- list(over16 = "")
response <- VERB("GET", url, query = queryString, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/exports/tracks?over16=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/exports/tracks') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
req.params['over16'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/exports/tracks";
let querystring = [
("over16", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/my/music/exports/tracks?over16=' \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET '{{baseUrl}}/my/music/exports/tracks?over16=' \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- '{{baseUrl}}/my/music/exports/tracks?over16='import Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/exports/tracks?over16=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Music Export Vendor Preferences (GET)
{{baseUrl}}/my/music/preferences/export/:vendor
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
vendor
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/preferences/export/:vendor");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/preferences/export/:vendor" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/preferences/export/:vendor"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/preferences/export/:vendor"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/preferences/export/:vendor");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/preferences/export/:vendor"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/preferences/export/:vendor HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/preferences/export/:vendor")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/preferences/export/:vendor"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export/:vendor")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/preferences/export/:vendor")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/preferences/export/:vendor');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/preferences/export/:vendor';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/preferences/export/:vendor',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export/:vendor")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/preferences/export/:vendor',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/preferences/export/:vendor');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/preferences/export/:vendor';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/preferences/export/:vendor"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/preferences/export/:vendor" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/preferences/export/:vendor",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/preferences/export/:vendor', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/preferences/export/:vendor');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/preferences/export/:vendor');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/preferences/export/:vendor' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/preferences/export/:vendor' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/preferences/export/:vendor", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/preferences/export/:vendor"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/preferences/export/:vendor"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/preferences/export/:vendor")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/preferences/export/:vendor') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/preferences/export/:vendor";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/music/preferences/export/:vendor \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/music/preferences/export/:vendor \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/preferences/export/:vendorimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/preferences/export/:vendor")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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
Music Export Vendor Preferences (POST)
{{baseUrl}}/my/music/preferences/export/:vendor
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
vendor
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/preferences/export/:vendor");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/music/preferences/export/:vendor" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/preferences/export/:vendor"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/music/preferences/export/:vendor"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/preferences/export/:vendor");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/preferences/export/:vendor"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/music/preferences/export/:vendor HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/music/preferences/export/:vendor")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/preferences/export/:vendor"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export/:vendor")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/music/preferences/export/:vendor")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/music/preferences/export/:vendor');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/preferences/export/:vendor';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/preferences/export/:vendor',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export/:vendor")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/preferences/export/:vendor',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/music/preferences/export/:vendor');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/preferences/export/:vendor';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/preferences/export/:vendor"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/preferences/export/:vendor" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/preferences/export/:vendor",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/music/preferences/export/:vendor', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/preferences/export/:vendor');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/preferences/export/:vendor');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/preferences/export/:vendor' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/preferences/export/:vendor' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/music/preferences/export/:vendor", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/preferences/export/:vendor"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/preferences/export/:vendor"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/preferences/export/:vendor")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/music/preferences/export/:vendor') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/preferences/export/:vendor";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/music/preferences/export/:vendor \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/music/preferences/export/:vendor \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/preferences/export/:vendorimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/preferences/export/:vendor")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Music Export Vendor Preferences (PUT)
{{baseUrl}}/my/music/preferences/export/:vendor
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
vendor
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/preferences/export/:vendor");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/my/music/preferences/export/:vendor" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/preferences/export/:vendor"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/my/music/preferences/export/:vendor"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/preferences/export/:vendor");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/preferences/export/:vendor"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/my/music/preferences/export/:vendor HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/music/preferences/export/:vendor")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/preferences/export/:vendor"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export/:vendor")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/my/music/preferences/export/:vendor")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/my/music/preferences/export/:vendor');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/preferences/export/:vendor';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/preferences/export/:vendor',
method: 'PUT',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export/:vendor")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/preferences/export/:vendor',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/my/music/preferences/export/:vendor');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/preferences/export/:vendor';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/preferences/export/:vendor"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/preferences/export/:vendor" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/preferences/export/:vendor",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/my/music/preferences/export/:vendor', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/preferences/export/:vendor');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/preferences/export/:vendor');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/preferences/export/:vendor' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/preferences/export/:vendor' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("PUT", "/baseUrl/my/music/preferences/export/:vendor", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/preferences/export/:vendor"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/preferences/export/:vendor"
response <- VERB("PUT", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/preferences/export/:vendor")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/my/music/preferences/export/:vendor') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/preferences/export/:vendor";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/my/music/preferences/export/:vendor \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http PUT {{baseUrl}}/my/music/preferences/export/:vendor \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method PUT \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/preferences/export/:vendorimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/preferences/export/:vendor")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Music Export Vendor Preferences
{{baseUrl}}/my/music/preferences/export/:vendor
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
vendor
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/preferences/export/:vendor");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/my/music/preferences/export/:vendor" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/preferences/export/:vendor"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/my/music/preferences/export/:vendor"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/preferences/export/:vendor");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/preferences/export/:vendor"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/my/music/preferences/export/:vendor HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/music/preferences/export/:vendor")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/preferences/export/:vendor"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export/:vendor")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/my/music/preferences/export/:vendor")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/my/music/preferences/export/:vendor');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/preferences/export/:vendor';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/preferences/export/:vendor',
method: 'DELETE',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/preferences/export/:vendor")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/preferences/export/:vendor',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/my/music/preferences/export/:vendor');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/music/preferences/export/:vendor',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/preferences/export/:vendor';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/preferences/export/:vendor"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/preferences/export/:vendor" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/preferences/export/:vendor",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/my/music/preferences/export/:vendor', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/preferences/export/:vendor');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/preferences/export/:vendor');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/preferences/export/:vendor' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/preferences/export/:vendor' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("DELETE", "/baseUrl/my/music/preferences/export/:vendor", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/preferences/export/:vendor"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/preferences/export/:vendor"
response <- VERB("DELETE", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/preferences/export/:vendor")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/my/music/preferences/export/:vendor') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/preferences/export/:vendor";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/my/music/preferences/export/:vendor \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http DELETE {{baseUrl}}/my/music/preferences/export/:vendor \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method DELETE \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/preferences/export/:vendorimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/preferences/export/:vendor")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Music Exports
{{baseUrl}}/my/music/export
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/music/export");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/music/export" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/music/export"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/music/export"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/music/export");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/music/export"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/music/export HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/music/export")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/music/export"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/music/export")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/music/export")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/music/export');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/music/export';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/music/export',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/music/export")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/music/export',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/music/export');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/music/export',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/music/export';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/music/export"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/music/export" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/music/export",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/music/export', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/music/export');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/music/export');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/music/export' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/music/export' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/music/export", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/music/export"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/music/export"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/music/export")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/music/export') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/music/export";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/music/export \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/music/export \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/music/exportimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/music/export")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Networks
{{baseUrl}}/radio/networks.json
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/radio/networks.json");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/radio/networks.json" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/radio/networks.json"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/radio/networks.json"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/radio/networks.json");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/radio/networks.json"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/radio/networks.json HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/radio/networks.json")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/radio/networks.json"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/radio/networks.json")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/radio/networks.json")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/radio/networks.json');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/networks.json',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/radio/networks.json';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/radio/networks.json',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/radio/networks.json")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/radio/networks.json',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/networks.json',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/radio/networks.json');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/networks.json',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/radio/networks.json';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/radio/networks.json"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/radio/networks.json" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/radio/networks.json",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/radio/networks.json', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/radio/networks.json');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/radio/networks.json');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/radio/networks.json' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/radio/networks.json' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/radio/networks.json", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/radio/networks.json"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/radio/networks.json"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/radio/networks.json")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/radio/networks.json') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/radio/networks.json";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/radio/networks.json \
--header 'x-api-key: 'http GET {{baseUrl}}/radio/networks.json \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/radio/networks.jsonimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/radio/networks.json")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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
Follow category
{{baseUrl}}/my/categories/follows
HEADERS
Authorization
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/categories/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/categories/follows" {:headers {:authorization ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/categories/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/categories/follows"),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/categories/follows");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/categories/follows"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/categories/follows HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/categories/follows")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/categories/follows"))
.header("authorization", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/categories/follows")
.post(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/categories/follows")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/categories/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/categories/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/categories/follows';
const options = {method: 'POST', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/categories/follows',
method: 'POST',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/categories/follows")
.post(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/categories/follows',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/categories/follows',
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/categories/follows');
req.headers({
authorization: '',
'x-api-key': ''
});
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}}/my/categories/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/categories/follows';
const options = {method: 'POST', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/categories/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/categories/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/categories/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/categories/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/categories/follows');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/categories/follows');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/categories/follows' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/categories/follows' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/categories/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/categories/follows"
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/categories/follows"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/categories/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/categories/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/categories/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/categories/follows \
--header 'authorization: ' \
--header 'x-api-key: 'http POST {{baseUrl}}/my/categories/follows \
authorization:'' \
x-api-key:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/categories/followsimport Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/categories/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List of followed categories
{{baseUrl}}/my/categories/follows
HEADERS
Authorization
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/categories/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/categories/follows" {:headers {:authorization ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/categories/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/categories/follows"),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/categories/follows");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/categories/follows"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/categories/follows HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/categories/follows")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/categories/follows"))
.header("authorization", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/categories/follows")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/categories/follows")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/categories/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/categories/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/categories/follows';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/categories/follows',
method: 'GET',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/categories/follows")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/categories/follows',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/categories/follows',
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/categories/follows');
req.headers({
authorization: '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/categories/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/categories/follows';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/categories/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/categories/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/categories/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/categories/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/categories/follows');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/categories/follows');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/categories/follows' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/categories/follows' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/categories/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/categories/follows"
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/categories/follows"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/categories/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/categories/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/categories/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/categories/follows \
--header 'authorization: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/my/categories/follows \
authorization:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/categories/followsimport Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/categories/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Unfollow category
{{baseUrl}}/my/categories/follows
HEADERS
Authorization
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/categories/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/my/categories/follows" {:headers {:authorization ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/categories/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/my/categories/follows"),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/categories/follows");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/categories/follows"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/my/categories/follows HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/categories/follows")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/categories/follows"))
.header("authorization", "")
.header("x-api-key", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/categories/follows")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/my/categories/follows")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/my/categories/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/categories/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/categories/follows';
const options = {method: 'DELETE', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/categories/follows',
method: 'DELETE',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/categories/follows")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/categories/follows',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/categories/follows',
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/my/categories/follows');
req.headers({
authorization: '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/categories/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/categories/follows';
const options = {method: 'DELETE', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/categories/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
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}}/my/categories/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/categories/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/my/categories/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/categories/follows');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/categories/follows');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/categories/follows' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/categories/follows' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("DELETE", "/baseUrl/my/categories/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/categories/follows"
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/categories/follows"
response <- VERB("DELETE", url, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/categories/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/my/categories/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/categories/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/my/categories/follows \
--header 'authorization: ' \
--header 'x-api-key: 'http DELETE {{baseUrl}}/my/categories/follows \
authorization:'' \
x-api-key:''wget --quiet \
--method DELETE \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/categories/followsimport Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/categories/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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
Follow network
{{baseUrl}}/my/networks/follows
HEADERS
Authorization
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/networks/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/networks/follows" {:headers {:authorization ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/networks/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/networks/follows"),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/networks/follows");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/networks/follows"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/networks/follows HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/networks/follows")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/networks/follows"))
.header("authorization", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/networks/follows")
.post(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/networks/follows")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/networks/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/networks/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/networks/follows';
const options = {method: 'POST', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/networks/follows',
method: 'POST',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/networks/follows")
.post(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/networks/follows',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/networks/follows',
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/networks/follows');
req.headers({
authorization: '',
'x-api-key': ''
});
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}}/my/networks/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/networks/follows';
const options = {method: 'POST', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/networks/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/networks/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/networks/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/networks/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/networks/follows');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/networks/follows');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/networks/follows' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/networks/follows' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/networks/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/networks/follows"
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/networks/follows"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/networks/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/networks/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/networks/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/networks/follows \
--header 'authorization: ' \
--header 'x-api-key: 'http POST {{baseUrl}}/my/networks/follows \
authorization:'' \
x-api-key:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/networks/followsimport Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/networks/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
List of followed networks
{{baseUrl}}/my/networks/follows
HEADERS
Authorization
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/networks/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/networks/follows" {:headers {:authorization ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/networks/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/networks/follows"),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/networks/follows");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/networks/follows"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/networks/follows HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/networks/follows")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/networks/follows"))
.header("authorization", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/networks/follows")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/networks/follows")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/networks/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/networks/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/networks/follows';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/networks/follows',
method: 'GET',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/networks/follows")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/networks/follows',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/networks/follows',
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/networks/follows');
req.headers({
authorization: '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/networks/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/networks/follows';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/networks/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/networks/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/networks/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/networks/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/networks/follows');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/networks/follows');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/networks/follows' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/networks/follows' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/networks/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/networks/follows"
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/networks/follows"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/networks/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/networks/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/networks/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/networks/follows \
--header 'authorization: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/my/networks/follows \
authorization:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/networks/followsimport Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/networks/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Unfollow network
{{baseUrl}}/my/networks/follows
HEADERS
Authorization
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/networks/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/my/networks/follows" {:headers {:authorization ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/networks/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/my/networks/follows"),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/networks/follows");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/networks/follows"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/my/networks/follows HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/networks/follows")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/networks/follows"))
.header("authorization", "")
.header("x-api-key", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/networks/follows")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/my/networks/follows")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/my/networks/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/networks/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/networks/follows';
const options = {method: 'DELETE', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/networks/follows',
method: 'DELETE',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/networks/follows")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/networks/follows',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/networks/follows',
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/my/networks/follows');
req.headers({
authorization: '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/networks/follows',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/networks/follows';
const options = {method: 'DELETE', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/networks/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
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}}/my/networks/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/networks/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/my/networks/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/networks/follows');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/networks/follows');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/networks/follows' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/networks/follows' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("DELETE", "/baseUrl/my/networks/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/networks/follows"
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/networks/follows"
response <- VERB("DELETE", url, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/networks/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/my/networks/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/networks/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/my/networks/follows \
--header 'authorization: ' \
--header 'x-api-key: 'http DELETE {{baseUrl}}/my/networks/follows \
authorization:'' \
x-api-key:''wget --quiet \
--method DELETE \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/networks/followsimport Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/networks/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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
Write Play Event
{{baseUrl}}/my/plays
HEADERS
Authorization
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/plays");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/plays" {:headers {:authorization ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/plays"
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/plays"),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/plays");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/plays"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/plays HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/plays")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/plays"))
.header("authorization", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/plays")
.post(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/plays")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/plays');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/plays',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/plays';
const options = {method: 'POST', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/plays',
method: 'POST',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/plays")
.post(null)
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/plays',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/plays',
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/plays');
req.headers({
authorization: '',
'x-api-key': ''
});
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}}/my/plays',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/plays';
const options = {method: 'POST', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/plays"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/plays" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/plays",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/plays', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/plays');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/plays');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/plays' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/plays' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/plays", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/plays"
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/plays"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/plays")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/plays') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/plays";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/plays \
--header 'authorization: ' \
--header 'x-api-key: 'http POST {{baseUrl}}/my/plays \
authorization:'' \
x-api-key:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/playsimport Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/plays")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Playspace Container by ID
{{baseUrl}}/my/playspace/containers/:id
HEADERS
Authorization
X-API-Key
QUERY PARAMS
id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/playspace/containers/:id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/playspace/containers/:id" {:headers {:authorization ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/playspace/containers/:id"
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/playspace/containers/:id"),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/playspace/containers/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/playspace/containers/:id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/playspace/containers/:id HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/playspace/containers/:id")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/playspace/containers/:id"))
.header("authorization", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/playspace/containers/:id")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/playspace/containers/:id")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/playspace/containers/:id');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/playspace/containers/:id',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/playspace/containers/:id';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/playspace/containers/:id',
method: 'GET',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/playspace/containers/:id")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/playspace/containers/:id',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/playspace/containers/:id',
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/playspace/containers/:id');
req.headers({
authorization: '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/playspace/containers/:id',
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/playspace/containers/:id';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/playspace/containers/:id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/playspace/containers/:id" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/playspace/containers/:id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/playspace/containers/:id', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/playspace/containers/:id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/playspace/containers/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/playspace/containers/:id' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/playspace/containers/:id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/playspace/containers/:id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/playspace/containers/:id"
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/playspace/containers/:id"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/playspace/containers/:id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/playspace/containers/:id') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/playspace/containers/:id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/playspace/containers/:id \
--header 'authorization: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/my/playspace/containers/:id \
authorization:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/playspace/containers/:idimport Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/playspace/containers/:id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Suggested Playspace Container
{{baseUrl}}/my/playspace/containers/suggested
HEADERS
Authorization
X-API-Key
QUERY PARAMS
previous_pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/playspace/containers/suggested?previous_pid=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/playspace/containers/suggested" {:headers {:authorization ""
:x-api-key ""}
:query-params {:previous_pid ""}})require "http/client"
url = "{{baseUrl}}/my/playspace/containers/suggested?previous_pid="
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/playspace/containers/suggested?previous_pid="),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/playspace/containers/suggested?previous_pid=");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/playspace/containers/suggested?previous_pid="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/playspace/containers/suggested?previous_pid= HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/playspace/containers/suggested?previous_pid=")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/playspace/containers/suggested?previous_pid="))
.header("authorization", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/playspace/containers/suggested?previous_pid=")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/playspace/containers/suggested?previous_pid=")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/playspace/containers/suggested?previous_pid=');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/playspace/containers/suggested',
params: {previous_pid: ''},
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/playspace/containers/suggested?previous_pid=';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/playspace/containers/suggested?previous_pid=',
method: 'GET',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/playspace/containers/suggested?previous_pid=")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/playspace/containers/suggested?previous_pid=',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/playspace/containers/suggested',
qs: {previous_pid: ''},
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/playspace/containers/suggested');
req.query({
previous_pid: ''
});
req.headers({
authorization: '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/playspace/containers/suggested',
params: {previous_pid: ''},
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/playspace/containers/suggested?previous_pid=';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/playspace/containers/suggested?previous_pid="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/playspace/containers/suggested?previous_pid=" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/playspace/containers/suggested?previous_pid=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/playspace/containers/suggested?previous_pid=', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/playspace/containers/suggested');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'previous_pid' => ''
]);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/playspace/containers/suggested');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'previous_pid' => ''
]));
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/playspace/containers/suggested?previous_pid=' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/playspace/containers/suggested?previous_pid=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/playspace/containers/suggested?previous_pid=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/playspace/containers/suggested"
querystring = {"previous_pid":""}
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/playspace/containers/suggested"
queryString <- list(previous_pid = "")
response <- VERB("GET", url, query = queryString, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/playspace/containers/suggested?previous_pid=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/playspace/containers/suggested') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
req.params['previous_pid'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/playspace/containers/suggested";
let querystring = [
("previous_pid", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/my/playspace/containers/suggested?previous_pid=' \
--header 'authorization: ' \
--header 'x-api-key: 'http GET '{{baseUrl}}/my/playspace/containers/suggested?previous_pid=' \
authorization:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- '{{baseUrl}}/my/playspace/containers/suggested?previous_pid='import Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/playspace/containers/suggested?previous_pid=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
All Podcasts
{{baseUrl}}/podcasts
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/podcasts" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/podcasts"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/podcasts"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/podcasts");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/podcasts"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/podcasts HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/podcasts")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/podcasts"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/podcasts")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/podcasts")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/podcasts');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/podcasts';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/podcasts',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/podcasts")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/podcasts',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/podcasts');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/podcasts';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/podcasts" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/podcasts",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/podcasts', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/podcasts');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/podcasts');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/podcasts", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/podcasts"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/podcasts"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/podcasts")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/podcasts') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/podcasts";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/podcasts \
--header 'x-api-key: 'http GET {{baseUrl}}/podcasts \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/podcastsimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Featured Podcasts
{{baseUrl}}/podcasts/featured
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts/featured");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/podcasts/featured" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/podcasts/featured"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/podcasts/featured"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/podcasts/featured");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/podcasts/featured"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/podcasts/featured HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/podcasts/featured")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/podcasts/featured"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/podcasts/featured")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/podcasts/featured")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/podcasts/featured');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts/featured',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/podcasts/featured';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/podcasts/featured',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/podcasts/featured")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/podcasts/featured',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts/featured',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/podcasts/featured');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts/featured',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/podcasts/featured';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts/featured"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/podcasts/featured" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/podcasts/featured",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/podcasts/featured', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/podcasts/featured');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/podcasts/featured');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts/featured' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts/featured' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/podcasts/featured", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/podcasts/featured"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/podcasts/featured"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/podcasts/featured")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/podcasts/featured') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/podcasts/featured";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/podcasts/featured \
--header 'x-api-key: 'http GET {{baseUrl}}/podcasts/featured \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/podcasts/featuredimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts/featured")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Podcast Episodes
{{baseUrl}}/podcasts/:pid/episodes
HEADERS
X-API-Key
QUERY PARAMS
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts/:pid/episodes");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/podcasts/:pid/episodes" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/podcasts/:pid/episodes"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/podcasts/:pid/episodes"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/podcasts/:pid/episodes");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/podcasts/:pid/episodes"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/podcasts/:pid/episodes HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/podcasts/:pid/episodes")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/podcasts/:pid/episodes"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/podcasts/:pid/episodes")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/podcasts/:pid/episodes")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/podcasts/:pid/episodes');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts/:pid/episodes',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/podcasts/:pid/episodes';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/podcasts/:pid/episodes',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/podcasts/:pid/episodes")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/podcasts/:pid/episodes',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts/:pid/episodes',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/podcasts/:pid/episodes');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts/:pid/episodes',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/podcasts/:pid/episodes';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts/:pid/episodes"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/podcasts/:pid/episodes" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/podcasts/:pid/episodes",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/podcasts/:pid/episodes', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/podcasts/:pid/episodes');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/podcasts/:pid/episodes');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts/:pid/episodes' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts/:pid/episodes' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/podcasts/:pid/episodes", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/podcasts/:pid/episodes"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/podcasts/:pid/episodes"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/podcasts/:pid/episodes")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/podcasts/:pid/episodes') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/podcasts/:pid/episodes";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/podcasts/:pid/episodes \
--header 'x-api-key: 'http GET {{baseUrl}}/podcasts/:pid/episodes \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/podcasts/:pid/episodesimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts/:pid/episodes")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Podcast
{{baseUrl}}/podcasts/:pid
HEADERS
X-API-Key
QUERY PARAMS
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/podcasts/:pid" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/podcasts/:pid"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/podcasts/:pid"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/podcasts/:pid");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/podcasts/:pid"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/podcasts/:pid HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/podcasts/:pid")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/podcasts/:pid"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/podcasts/:pid")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/podcasts/:pid")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/podcasts/:pid');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts/:pid',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/podcasts/:pid';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/podcasts/:pid',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/podcasts/:pid")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/podcasts/:pid',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts/:pid',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/podcasts/:pid');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/podcasts/:pid',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/podcasts/:pid';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/podcasts/:pid" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/podcasts/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/podcasts/:pid', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/podcasts/:pid');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/podcasts/:pid');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts/:pid' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts/:pid' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/podcasts/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/podcasts/:pid"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/podcasts/:pid"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/podcasts/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/podcasts/:pid') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/podcasts/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/podcasts/:pid \
--header 'x-api-key: 'http GET {{baseUrl}}/podcasts/:pid \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/podcasts/:pidimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Available radio programme by Pid
{{baseUrl}}/radio/programmes/:pid
HEADERS
X-API-Key
QUERY PARAMS
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/radio/programmes/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/radio/programmes/:pid" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/radio/programmes/:pid"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/radio/programmes/:pid"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/radio/programmes/:pid");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/radio/programmes/:pid"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/radio/programmes/:pid HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/radio/programmes/:pid")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/radio/programmes/:pid"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/radio/programmes/:pid")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/radio/programmes/:pid")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/radio/programmes/:pid');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/programmes/:pid',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/radio/programmes/:pid';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/radio/programmes/:pid',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/radio/programmes/:pid")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/radio/programmes/:pid',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/programmes/:pid',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/radio/programmes/:pid');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/programmes/:pid',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/radio/programmes/:pid';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/radio/programmes/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/radio/programmes/:pid" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/radio/programmes/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/radio/programmes/:pid', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/radio/programmes/:pid');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/radio/programmes/:pid');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/radio/programmes/:pid' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/radio/programmes/:pid' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/radio/programmes/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/radio/programmes/:pid"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/radio/programmes/:pid"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/radio/programmes/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/radio/programmes/:pid') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/radio/programmes/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/radio/programmes/:pid \
--header 'x-api-key: 'http GET {{baseUrl}}/radio/programmes/:pid \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/radio/programmes/:pidimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/radio/programmes/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Popular Episodes & Clips
{{baseUrl}}/radio/popular
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/radio/popular");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/radio/popular" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/radio/popular"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/radio/popular"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/radio/popular");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/radio/popular"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/radio/popular HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/radio/popular")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/radio/popular"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/radio/popular")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/radio/popular")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/radio/popular');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/popular',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/radio/popular';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/radio/popular',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/radio/popular")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/radio/popular',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/popular',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/radio/popular');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/popular',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/radio/popular';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/radio/popular"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/radio/popular" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/radio/popular",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/radio/popular', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/radio/popular');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/radio/popular');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/radio/popular' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/radio/popular' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/radio/popular", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/radio/popular"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/radio/popular"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/radio/popular")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/radio/popular') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/radio/popular";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/radio/popular \
--header 'x-api-key: 'http GET {{baseUrl}}/radio/popular \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/radio/popularimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/radio/popular")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Radio programmes
{{baseUrl}}/radio/programmes
HEADERS
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/radio/programmes");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/radio/programmes" {:headers {:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/radio/programmes"
headers = HTTP::Headers{
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/radio/programmes"),
Headers =
{
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/radio/programmes");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/radio/programmes"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/radio/programmes HTTP/1.1
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/radio/programmes")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/radio/programmes"))
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/radio/programmes")
.get()
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/radio/programmes")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/radio/programmes');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/programmes',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/radio/programmes';
const options = {method: 'GET', headers: {'x-api-key': ''}};
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}}/radio/programmes',
method: 'GET',
headers: {
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/radio/programmes")
.get()
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/radio/programmes',
headers: {
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/programmes',
headers: {'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/radio/programmes');
req.headers({
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/radio/programmes',
headers: {'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/radio/programmes';
const options = {method: 'GET', headers: {'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/radio/programmes"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/radio/programmes" in
let headers = Header.add (Header.init ()) "x-api-key" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/radio/programmes",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/radio/programmes', [
'headers' => [
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/radio/programmes');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/radio/programmes');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/radio/programmes' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/radio/programmes' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-api-key': "" }
conn.request("GET", "/baseUrl/radio/programmes", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/radio/programmes"
headers = {"x-api-key": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/radio/programmes"
response <- VERB("GET", url, add_headers('x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/radio/programmes")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/radio/programmes') do |req|
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/radio/programmes";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/radio/programmes \
--header 'x-api-key: 'http GET {{baseUrl}}/radio/programmes \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/radio/programmesimport Foundation
let headers = ["x-api-key": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/radio/programmes")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Recommended Programmes
{{baseUrl}}/my/programmes/recommendations
HEADERS
Authorization
X-API-Key
QUERY PARAMS
rights
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/programmes/recommendations?rights=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/programmes/recommendations" {:headers {:authorization ""
:x-api-key ""}
:query-params {:rights ""}})require "http/client"
url = "{{baseUrl}}/my/programmes/recommendations?rights="
headers = HTTP::Headers{
"authorization" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/programmes/recommendations?rights="),
Headers =
{
{ "authorization", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/programmes/recommendations?rights=");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/programmes/recommendations?rights="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/programmes/recommendations?rights= HTTP/1.1
Authorization:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/programmes/recommendations?rights=")
.setHeader("authorization", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/programmes/recommendations?rights="))
.header("authorization", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/programmes/recommendations?rights=")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/programmes/recommendations?rights=")
.header("authorization", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/programmes/recommendations?rights=');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/programmes/recommendations',
params: {rights: ''},
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/programmes/recommendations?rights=';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
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}}/my/programmes/recommendations?rights=',
method: 'GET',
headers: {
authorization: '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/programmes/recommendations?rights=")
.get()
.addHeader("authorization", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/programmes/recommendations?rights=',
headers: {
authorization: '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/programmes/recommendations',
qs: {rights: ''},
headers: {authorization: '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/programmes/recommendations');
req.query({
rights: ''
});
req.headers({
authorization: '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/programmes/recommendations',
params: {rights: ''},
headers: {authorization: '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/programmes/recommendations?rights=';
const options = {method: 'GET', headers: {authorization: '', 'x-api-key': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/programmes/recommendations?rights="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/programmes/recommendations?rights=" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/programmes/recommendations?rights=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/programmes/recommendations?rights=', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/programmes/recommendations');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'rights' => ''
]);
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/programmes/recommendations');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'rights' => ''
]));
$request->setHeaders([
'authorization' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/programmes/recommendations?rights=' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/programmes/recommendations?rights=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/programmes/recommendations?rights=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/programmes/recommendations"
querystring = {"rights":""}
headers = {
"authorization": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/programmes/recommendations"
queryString <- list(rights = "")
response <- VERB("GET", url, query = queryString, add_headers('authorization' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/programmes/recommendations?rights=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/programmes/recommendations') do |req|
req.headers['authorization'] = ''
req.headers['x-api-key'] = ''
req.params['rights'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/programmes/recommendations";
let querystring = [
("rights", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/my/programmes/recommendations?rights=' \
--header 'authorization: ' \
--header 'x-api-key: 'http GET '{{baseUrl}}/my/programmes/recommendations?rights=' \
authorization:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-api-key: ' \
--output-document \
- '{{baseUrl}}/my/programmes/recommendations?rights='import Foundation
let headers = [
"authorization": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/programmes/recommendations?rights=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Favourite Episode or Clip (GET)
{{baseUrl}}/my/radio/favourites/:type/:pid
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/favourites/:type/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/radio/favourites/:type/:pid" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/favourites/:type/:pid"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/radio/favourites/:type/:pid"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/favourites/:type/:pid");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/favourites/:type/:pid"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/radio/favourites/:type/:pid HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/radio/favourites/:type/:pid")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/favourites/:type/:pid"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type/:pid")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/radio/favourites/:type/:pid")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/radio/favourites/:type/:pid');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/favourites/:type/:pid';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/favourites/:type/:pid',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type/:pid")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/favourites/:type/:pid',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/radio/favourites/:type/:pid');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/favourites/:type/:pid';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/favourites/:type/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/favourites/:type/:pid" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/favourites/:type/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/radio/favourites/:type/:pid', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/favourites/:type/:pid');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/favourites/:type/:pid');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/favourites/:type/:pid' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/favourites/:type/:pid' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/radio/favourites/:type/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/favourites/:type/:pid"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/favourites/:type/:pid"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/favourites/:type/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/radio/favourites/:type/:pid') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/favourites/:type/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/radio/favourites/:type/:pid \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/radio/favourites/:type/:pid \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/favourites/:type/:pidimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/favourites/:type/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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
Favourite Episode or Clip (POST)
{{baseUrl}}/my/radio/favourites/:type/:pid
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/favourites/:type/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/radio/favourites/:type/:pid" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/favourites/:type/:pid"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/radio/favourites/:type/:pid"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/favourites/:type/:pid");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/favourites/:type/:pid"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/radio/favourites/:type/:pid HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/radio/favourites/:type/:pid")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/favourites/:type/:pid"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type/:pid")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/radio/favourites/:type/:pid")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/radio/favourites/:type/:pid');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/favourites/:type/:pid';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/favourites/:type/:pid',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type/:pid")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/favourites/:type/:pid',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/radio/favourites/:type/:pid');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/favourites/:type/:pid';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/favourites/:type/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/favourites/:type/:pid" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/favourites/:type/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/radio/favourites/:type/:pid', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/favourites/:type/:pid');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/favourites/:type/:pid');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/favourites/:type/:pid' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/favourites/:type/:pid' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/radio/favourites/:type/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/favourites/:type/:pid"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/favourites/:type/:pid"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/favourites/:type/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/radio/favourites/:type/:pid') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/favourites/:type/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/radio/favourites/:type/:pid \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/radio/favourites/:type/:pid \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/favourites/:type/:pidimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/favourites/:type/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Favourite Episode or Clip (PUT)
{{baseUrl}}/my/radio/favourites/:type/:pid
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/favourites/:type/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/my/radio/favourites/:type/:pid" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/favourites/:type/:pid"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/my/radio/favourites/:type/:pid"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/favourites/:type/:pid");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/favourites/:type/:pid"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/my/radio/favourites/:type/:pid HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/radio/favourites/:type/:pid")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/favourites/:type/:pid"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type/:pid")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/my/radio/favourites/:type/:pid")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/my/radio/favourites/:type/:pid');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/favourites/:type/:pid';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/favourites/:type/:pid',
method: 'PUT',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type/:pid")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/favourites/:type/:pid',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/my/radio/favourites/:type/:pid');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/favourites/:type/:pid';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/favourites/:type/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/favourites/:type/:pid" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/favourites/:type/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/my/radio/favourites/:type/:pid', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/favourites/:type/:pid');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/favourites/:type/:pid');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/favourites/:type/:pid' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/favourites/:type/:pid' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("PUT", "/baseUrl/my/radio/favourites/:type/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/favourites/:type/:pid"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/favourites/:type/:pid"
response <- VERB("PUT", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/favourites/:type/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/my/radio/favourites/:type/:pid') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/favourites/:type/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/my/radio/favourites/:type/:pid \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http PUT {{baseUrl}}/my/radio/favourites/:type/:pid \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method PUT \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/favourites/:type/:pidimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/favourites/:type/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Favourite Episode or Clip
{{baseUrl}}/my/radio/favourites/:type/:pid
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/favourites/:type/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/my/radio/favourites/:type/:pid" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/favourites/:type/:pid"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/my/radio/favourites/:type/:pid"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/favourites/:type/:pid");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/favourites/:type/:pid"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/my/radio/favourites/:type/:pid HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/radio/favourites/:type/:pid")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/favourites/:type/:pid"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type/:pid")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/my/radio/favourites/:type/:pid")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/my/radio/favourites/:type/:pid');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/favourites/:type/:pid';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/favourites/:type/:pid',
method: 'DELETE',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type/:pid")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/favourites/:type/:pid',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/my/radio/favourites/:type/:pid');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/radio/favourites/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/favourites/:type/:pid';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/favourites/:type/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/favourites/:type/:pid" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/favourites/:type/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/my/radio/favourites/:type/:pid', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/favourites/:type/:pid');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/favourites/:type/:pid');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/favourites/:type/:pid' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/favourites/:type/:pid' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("DELETE", "/baseUrl/my/radio/favourites/:type/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/favourites/:type/:pid"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/favourites/:type/:pid"
response <- VERB("DELETE", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/favourites/:type/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/my/radio/favourites/:type/:pid') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/favourites/:type/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/my/radio/favourites/:type/:pid \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http DELETE {{baseUrl}}/my/radio/favourites/:type/:pid \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method DELETE \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/favourites/:type/:pidimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/favourites/:type/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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
Favourite Episodes and Clips (POST)
{{baseUrl}}/my/radio/favourites
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/favourites");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/radio/favourites" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/favourites"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/radio/favourites"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/favourites");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/favourites"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/radio/favourites HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/radio/favourites")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/favourites"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/favourites")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/radio/favourites")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/radio/favourites');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/radio/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/favourites';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/favourites',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/favourites")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/favourites',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/radio/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/radio/favourites');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/radio/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/favourites';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/favourites"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/favourites" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/favourites",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/radio/favourites', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/favourites');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/favourites');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/favourites' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/favourites' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/radio/favourites", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/favourites"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/favourites"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/favourites")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/radio/favourites') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/favourites";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/radio/favourites \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/radio/favourites \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/favouritesimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/favourites")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Favourite Episodes and Clips (PUT)
{{baseUrl}}/my/radio/favourites
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/favourites");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/my/radio/favourites" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/favourites"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/my/radio/favourites"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/favourites");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/favourites"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/my/radio/favourites HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/radio/favourites")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/favourites"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/favourites")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/my/radio/favourites")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/my/radio/favourites');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/favourites';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/favourites',
method: 'PUT',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/favourites")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/favourites',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/my/radio/favourites');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/favourites';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/favourites"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/favourites" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/favourites",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/my/radio/favourites', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/favourites');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/favourites');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/favourites' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/favourites' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("PUT", "/baseUrl/my/radio/favourites", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/favourites"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/favourites"
response <- VERB("PUT", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/favourites")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/my/radio/favourites') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/favourites";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/my/radio/favourites \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http PUT {{baseUrl}}/my/radio/favourites \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method PUT \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/favouritesimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/favourites")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Favourite Episodes and Clips by Type
{{baseUrl}}/my/radio/favourites/:type
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/favourites/:type");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/radio/favourites/:type" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/favourites/:type"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/radio/favourites/:type"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/favourites/:type");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/favourites/:type"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/radio/favourites/:type HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/radio/favourites/:type")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/favourites/:type"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/radio/favourites/:type")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/radio/favourites/:type');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/favourites/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/favourites/:type';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/favourites/:type',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/favourites/:type")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/favourites/:type',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/favourites/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/radio/favourites/:type');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/favourites/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/favourites/:type';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/favourites/:type"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/favourites/:type" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/favourites/:type",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/radio/favourites/:type', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/favourites/:type');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/favourites/:type');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/favourites/:type' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/favourites/:type' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/radio/favourites/:type", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/favourites/:type"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/favourites/:type"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/favourites/:type")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/radio/favourites/:type') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/favourites/:type";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/radio/favourites/:type \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/radio/favourites/:type \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/favourites/:typeimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/favourites/:type")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Favourite Episodes and Clips
{{baseUrl}}/my/radio/favourites
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/favourites");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/radio/favourites" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/favourites"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/radio/favourites"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/favourites");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/favourites"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/radio/favourites HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/radio/favourites")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/favourites"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/favourites")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/radio/favourites")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/radio/favourites');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/favourites';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/favourites',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/favourites")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/favourites',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/radio/favourites');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/favourites',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/favourites';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/favourites"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/favourites" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/favourites",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/radio/favourites', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/favourites');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/favourites');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/favourites' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/favourites' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/radio/favourites", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/favourites"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/favourites"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/favourites")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/radio/favourites') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/favourites";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/radio/favourites \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/radio/favourites \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/favouritesimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/favourites")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Followed Brand or Series (GET)
{{baseUrl}}/my/radio/follows/:type/:pid
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/follows/:type/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/radio/follows/:type/:pid" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/follows/:type/:pid"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/radio/follows/:type/:pid"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/follows/:type/:pid");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/follows/:type/:pid"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/radio/follows/:type/:pid HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/radio/follows/:type/:pid")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/follows/:type/:pid"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type/:pid")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/radio/follows/:type/:pid")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/radio/follows/:type/:pid');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/follows/:type/:pid';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/follows/:type/:pid',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type/:pid")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/follows/:type/:pid',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/radio/follows/:type/:pid');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/follows/:type/:pid';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/follows/:type/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/follows/:type/:pid" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/follows/:type/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/radio/follows/:type/:pid', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/follows/:type/:pid');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/follows/:type/:pid');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/follows/:type/:pid' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/follows/:type/:pid' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/radio/follows/:type/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/follows/:type/:pid"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/follows/:type/:pid"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/follows/:type/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/radio/follows/:type/:pid') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/follows/:type/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/radio/follows/:type/:pid \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/radio/follows/:type/:pid \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/follows/:type/:pidimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/follows/:type/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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
Followed Brand or Series (POST)
{{baseUrl}}/my/radio/follows/:type/:pid
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/follows/:type/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/radio/follows/:type/:pid" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/follows/:type/:pid"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/radio/follows/:type/:pid"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/follows/:type/:pid");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/follows/:type/:pid"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/radio/follows/:type/:pid HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/radio/follows/:type/:pid")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/follows/:type/:pid"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type/:pid")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/radio/follows/:type/:pid")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/radio/follows/:type/:pid');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/follows/:type/:pid';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/follows/:type/:pid',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type/:pid")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/follows/:type/:pid',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/radio/follows/:type/:pid');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/follows/:type/:pid';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/follows/:type/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/follows/:type/:pid" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/follows/:type/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/radio/follows/:type/:pid', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/follows/:type/:pid');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/follows/:type/:pid');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/follows/:type/:pid' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/follows/:type/:pid' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/radio/follows/:type/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/follows/:type/:pid"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/follows/:type/:pid"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/follows/:type/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/radio/follows/:type/:pid') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/follows/:type/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/radio/follows/:type/:pid \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/radio/follows/:type/:pid \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/follows/:type/:pidimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/follows/:type/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Followed Brand or Series (PUT)
{{baseUrl}}/my/radio/follows/:type/:pid
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/follows/:type/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/my/radio/follows/:type/:pid" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/follows/:type/:pid"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/my/radio/follows/:type/:pid"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/follows/:type/:pid");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/follows/:type/:pid"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/my/radio/follows/:type/:pid HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/radio/follows/:type/:pid")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/follows/:type/:pid"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type/:pid")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/my/radio/follows/:type/:pid")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/my/radio/follows/:type/:pid');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/follows/:type/:pid';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/follows/:type/:pid',
method: 'PUT',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type/:pid")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/follows/:type/:pid',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/my/radio/follows/:type/:pid');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/follows/:type/:pid';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/follows/:type/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/follows/:type/:pid" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/follows/:type/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/my/radio/follows/:type/:pid', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/follows/:type/:pid');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/follows/:type/:pid');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/follows/:type/:pid' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/follows/:type/:pid' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("PUT", "/baseUrl/my/radio/follows/:type/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/follows/:type/:pid"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/follows/:type/:pid"
response <- VERB("PUT", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/follows/:type/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/my/radio/follows/:type/:pid') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/follows/:type/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/my/radio/follows/:type/:pid \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http PUT {{baseUrl}}/my/radio/follows/:type/:pid \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method PUT \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/follows/:type/:pidimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/follows/:type/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Followed Brand or Series
{{baseUrl}}/my/radio/follows/:type/:pid
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
pid
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/follows/:type/:pid");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/my/radio/follows/:type/:pid" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/follows/:type/:pid"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/my/radio/follows/:type/:pid"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/follows/:type/:pid");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/follows/:type/:pid"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/my/radio/follows/:type/:pid HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/my/radio/follows/:type/:pid")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/follows/:type/:pid"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type/:pid")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/my/radio/follows/:type/:pid")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/my/radio/follows/:type/:pid');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/follows/:type/:pid';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/follows/:type/:pid',
method: 'DELETE',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type/:pid")
.delete(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/follows/:type/:pid',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/my/radio/follows/:type/:pid');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/my/radio/follows/:type/:pid',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/follows/:type/:pid';
const options = {
method: 'DELETE',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/follows/:type/:pid"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/follows/:type/:pid" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/follows/:type/:pid",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/my/radio/follows/:type/:pid', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/follows/:type/:pid');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/follows/:type/:pid');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/follows/:type/:pid' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/follows/:type/:pid' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("DELETE", "/baseUrl/my/radio/follows/:type/:pid", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/follows/:type/:pid"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/follows/:type/:pid"
response <- VERB("DELETE", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/follows/:type/:pid")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/my/radio/follows/:type/:pid') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/follows/:type/:pid";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/my/radio/follows/:type/:pid \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http DELETE {{baseUrl}}/my/radio/follows/:type/:pid \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method DELETE \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/follows/:type/:pidimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/follows/:type/:pid")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
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
Followed Brands and Series (POST)
{{baseUrl}}/my/radio/follows
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/my/radio/follows" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/my/radio/follows"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/follows");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/follows"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/my/radio/follows HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/my/radio/follows")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/follows"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/follows")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/my/radio/follows")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/my/radio/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/my/radio/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/follows';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/follows',
method: 'POST',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/follows")
.post(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/follows',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/my/radio/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/my/radio/follows');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
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}}/my/radio/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/follows';
const options = {
method: 'POST',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/my/radio/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/follows');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/follows');
$request->setRequestMethod('POST');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/follows' -Method POST -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/follows' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("POST", "/baseUrl/my/radio/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/follows"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/follows"
response <- VERB("POST", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/my/radio/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/my/radio/follows \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http POST {{baseUrl}}/my/radio/follows \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method POST \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/followsimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Followed Brands and Series (PUT)
{{baseUrl}}/my/radio/follows
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/my/radio/follows" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/my/radio/follows"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/follows");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/follows"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/my/radio/follows HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/my/radio/follows")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/follows"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/follows")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/my/radio/follows")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/my/radio/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/follows';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/follows',
method: 'PUT',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/follows")
.put(null)
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/follows',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/my/radio/follows');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/my/radio/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/follows';
const options = {
method: 'PUT',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/my/radio/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/follows');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/follows');
$request->setRequestMethod('PUT');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/follows' -Method PUT -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/follows' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("PUT", "/baseUrl/my/radio/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/follows"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/follows"
response <- VERB("PUT", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/my/radio/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/my/radio/follows \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http PUT {{baseUrl}}/my/radio/follows \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method PUT \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/followsimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Followed Brands and Series
{{baseUrl}}/my/radio/follows
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/follows");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/radio/follows" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/follows"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/radio/follows"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/follows");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/follows"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/radio/follows HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/radio/follows")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/follows"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/follows")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/radio/follows")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/radio/follows');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/follows';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/follows',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/follows")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/follows',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/radio/follows');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/follows',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/follows';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/follows"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/follows" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/follows",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/radio/follows', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/follows');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/follows');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/follows' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/follows' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/radio/follows", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/follows"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/follows"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/follows")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/radio/follows') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/follows";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/radio/follows \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/radio/follows \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/followsimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/follows")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Followed Brands or Series by Type
{{baseUrl}}/my/radio/follows/:type
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
QUERY PARAMS
type
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/follows/:type");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/radio/follows/:type" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/follows/:type"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/radio/follows/:type"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/follows/:type");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/follows/:type"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/radio/follows/:type HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/radio/follows/:type")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/follows/:type"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/radio/follows/:type")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/radio/follows/:type');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/follows/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/follows/:type';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/follows/:type',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/follows/:type")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/follows/:type',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/follows/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/radio/follows/:type');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/follows/:type',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/follows/:type';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/follows/:type"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/follows/:type" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/follows/:type",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/radio/follows/:type', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/follows/:type');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/follows/:type');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/follows/:type' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/follows/:type' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/radio/follows/:type", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/follows/:type"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/follows/:type"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/follows/:type")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/radio/follows/:type') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/follows/:type";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/radio/follows/:type \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/radio/follows/:type \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/follows/:typeimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/follows/:type")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Played Episode or Clip
{{baseUrl}}/my/radio/plays
HEADERS
Authorization
X-Authentication-Provider
X-API-Key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/my/radio/plays");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: ");
headers = curl_slist_append(headers, "x-authentication-provider: ");
headers = curl_slist_append(headers, "x-api-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/my/radio/plays" {:headers {:authorization ""
:x-authentication-provider ""
:x-api-key ""}})require "http/client"
url = "{{baseUrl}}/my/radio/plays"
headers = HTTP::Headers{
"authorization" => ""
"x-authentication-provider" => ""
"x-api-key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/my/radio/plays"),
Headers =
{
{ "authorization", "" },
{ "x-authentication-provider", "" },
{ "x-api-key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/my/radio/plays");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "");
request.AddHeader("x-authentication-provider", "");
request.AddHeader("x-api-key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/my/radio/plays"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("authorization", "")
req.Header.Add("x-authentication-provider", "")
req.Header.Add("x-api-key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/my/radio/plays HTTP/1.1
Authorization:
X-Authentication-Provider:
X-Api-Key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/my/radio/plays")
.setHeader("authorization", "")
.setHeader("x-authentication-provider", "")
.setHeader("x-api-key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/my/radio/plays"))
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/my/radio/plays")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/my/radio/plays")
.header("authorization", "")
.header("x-authentication-provider", "")
.header("x-api-key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/my/radio/plays');
xhr.setRequestHeader('authorization', '');
xhr.setRequestHeader('x-authentication-provider', '');
xhr.setRequestHeader('x-api-key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/plays',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/my/radio/plays';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
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}}/my/radio/plays',
method: 'GET',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/my/radio/plays")
.get()
.addHeader("authorization", "")
.addHeader("x-authentication-provider", "")
.addHeader("x-api-key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/my/radio/plays',
headers: {
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/plays',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/my/radio/plays');
req.headers({
authorization: '',
'x-authentication-provider': '',
'x-api-key': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/my/radio/plays',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/my/radio/plays';
const options = {
method: 'GET',
headers: {authorization: '', 'x-authentication-provider': '', 'x-api-key': ''}
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"authorization": @"",
@"x-authentication-provider": @"",
@"x-api-key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/my/radio/plays"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
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}}/my/radio/plays" in
let headers = Header.add_list (Header.init ()) [
("authorization", "");
("x-authentication-provider", "");
("x-api-key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/my/radio/plays",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"authorization: ",
"x-api-key: ",
"x-authentication-provider: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/my/radio/plays', [
'headers' => [
'authorization' => '',
'x-api-key' => '',
'x-authentication-provider' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/my/radio/plays');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/my/radio/plays');
$request->setRequestMethod('GET');
$request->setHeaders([
'authorization' => '',
'x-authentication-provider' => '',
'x-api-key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/my/radio/plays' -Method GET -Headers $headers$headers=@{}
$headers.Add("authorization", "")
$headers.Add("x-authentication-provider", "")
$headers.Add("x-api-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/my/radio/plays' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'authorization': "",
'x-authentication-provider': "",
'x-api-key': ""
}
conn.request("GET", "/baseUrl/my/radio/plays", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/my/radio/plays"
headers = {
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/my/radio/plays"
response <- VERB("GET", url, add_headers('authorization' = '', 'x-authentication-provider' = '', 'x-api-key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/my/radio/plays")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["authorization"] = ''
request["x-authentication-provider"] = ''
request["x-api-key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/my/radio/plays') do |req|
req.headers['authorization'] = ''
req.headers['x-authentication-provider'] = ''
req.headers['x-api-key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/my/radio/plays";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("authorization", "".parse().unwrap());
headers.insert("x-authentication-provider", "".parse().unwrap());
headers.insert("x-api-key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/my/radio/plays \
--header 'authorization: ' \
--header 'x-api-key: ' \
--header 'x-authentication-provider: 'http GET {{baseUrl}}/my/radio/plays \
authorization:'' \
x-api-key:'' \
x-authentication-provider:''wget --quiet \
--method GET \
--header 'authorization: ' \
--header 'x-authentication-provider: ' \
--header 'x-api-key: ' \
--output-document \
- {{baseUrl}}/my/radio/playsimport Foundation
let headers = [
"authorization": "",
"x-authentication-provider": "",
"x-api-key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/my/radio/plays")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
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()