BBC iPlayer Business Layer

GET Programmes by initial title character

{{baseUrl}}/atoz/:letter/programmes

QUERY PARAMS

rights

page

per_page

initial_child_count

sort

sort_direction

availability

letter

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/atoz/:letter/programmes" {:query-params {:rights ""
                                                                                  :page ""
                                                                                  :per_page ""
                                                                                  :initial_child_count ""
                                                                                  :sort ""
                                                                                  :sort_direction ""
                                                                                  :availability ""}})

require "http/client"

url = "{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="))
    .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}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .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}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/atoz/:letter/programmes',
  params: {
    rights: '',
    page: '',
    per_page: '',
    initial_child_count: '',
    sort: '',
    sort_direction: '',
    availability: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/atoz/:letter/programmes',
  qs: {
    rights: '',
    page: '',
    per_page: '',
    initial_child_count: '',
    sort: '',
    sort_direction: '',
    availability: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/atoz/:letter/programmes');

req.query({
  rights: '',
  page: '',
  per_page: '',
  initial_child_count: '',
  sort: '',
  sort_direction: '',
  availability: ''
});

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}}/atoz/:letter/programmes',
  params: {
    rights: '',
    page: '',
    per_page: '',
    initial_child_count: '',
    sort: '',
    sort_direction: '',
    availability: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/atoz/:letter/programmes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'page' => '',
  'per_page' => '',
  'initial_child_count' => '',
  'sort' => '',
  'sort_direction' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/atoz/:letter/programmes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'page' => '',
  'per_page' => '',
  'initial_child_count' => '',
  'sort' => '',
  'sort_direction' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/atoz/:letter/programmes"

querystring = {"rights":"","page":"","per_page":"","initial_child_count":"","sort":"","sort_direction":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/atoz/:letter/programmes"

queryString <- list(
  rights = "",
  page = "",
  per_page = "",
  initial_child_count = "",
  sort = "",
  sort_direction = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/atoz/:letter/programmes') do |req|
  req.params['rights'] = ''
  req.params['page'] = ''
  req.params['per_page'] = ''
  req.params['initial_child_count'] = ''
  req.params['sort'] = ''
  req.params['sort_direction'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/atoz/:letter/programmes";

    let querystring = [
        ("rights", ""),
        ("page", ""),
        ("per_page", ""),
        ("initial_child_count", ""),
        ("sort", ""),
        ("sort_direction", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability='

http GET '{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/atoz/:letter/programmes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get categories

{{baseUrl}}/categories

QUERY PARAMS

lang

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories?lang=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/categories" {:query-params {:lang ""}})

require "http/client"

url = "{{baseUrl}}/categories?lang="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/categories?lang="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/categories?lang=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/categories?lang="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/categories?lang= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/categories?lang=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/categories?lang="))
    .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?lang=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/categories?lang=")
  .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?lang=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories',
  params: {lang: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/categories?lang=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/categories?lang=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/categories?lang=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/categories?lang=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/categories', qs: {lang: ''}};

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.query({
  lang: ''
});

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',
  params: {lang: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/categories?lang=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/categories?lang="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/categories?lang=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/categories?lang=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/categories?lang=');

echo $response->getBody();

setUrl('{{baseUrl}}/categories');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/categories');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories?lang=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories?lang=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/categories?lang=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/categories"

querystring = {"lang":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories"

queryString <- list(lang = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories?lang=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/categories') do |req|
  req.params['lang'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/categories";

    let querystring = [
        ("lang", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/categories?lang='

http GET '{{baseUrl}}/categories?lang='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/categories?lang='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/categories?lang=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get sub-categories

{{baseUrl}}/categories/:category

QUERY PARAMS

lang

category

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories/:category?lang=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/categories/:category" {:query-params {:lang ""}})

require "http/client"

url = "{{baseUrl}}/categories/:category?lang="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/categories/:category?lang="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/categories/:category?lang=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/categories/:category?lang="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/categories/:category?lang= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/categories/:category?lang=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/categories/:category?lang="))
    .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/:category?lang=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/categories/:category?lang=")
  .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/:category?lang=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories/:category',
  params: {lang: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/categories/:category?lang=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/categories/:category?lang=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/categories/:category?lang=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/categories/:category?lang=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories/:category',
  qs: {lang: ''}
};

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/:category');

req.query({
  lang: ''
});

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/:category',
  params: {lang: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/categories/:category?lang=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/categories/:category?lang="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/categories/:category?lang=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/categories/:category?lang=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/categories/:category?lang=');

echo $response->getBody();

setUrl('{{baseUrl}}/categories/:category');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/categories/:category');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories/:category?lang=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories/:category?lang=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/categories/:category?lang=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/categories/:category"

querystring = {"lang":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories/:category"

queryString <- list(lang = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories/:category?lang=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/categories/:category') do |req|
  req.params['lang'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/categories/:category";

    let querystring = [
        ("lang", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/categories/:category?lang='

http GET '{{baseUrl}}/categories/:category?lang='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/categories/:category?lang='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/categories/:category?lang=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get schedule by channel

{{baseUrl}}/channels/:channel/schedule/:date

QUERY PARAMS

lang

rights

availability

channel

date

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/channels/:channel/schedule/:date" {:query-params {:lang ""
                                                                                           :rights ""
                                                                                           :availability ""}})

require "http/client"

url = "{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/channels/:channel/schedule/:date?lang=&rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability="))
    .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}}/channels/:channel/schedule/:date?lang=&rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=")
  .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}}/channels/:channel/schedule/:date?lang=&rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/channels/:channel/schedule/:date',
  params: {lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:channel/schedule/:date?lang=&rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/channels/:channel/schedule/:date',
  qs: {lang: '', rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/channels/:channel/schedule/:date');

req.query({
  lang: '',
  rights: '',
  availability: ''
});

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}}/channels/:channel/schedule/:date',
  params: {lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channel/schedule/:date');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => '',
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels/:channel/schedule/:date');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => '',
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/channels/:channel/schedule/:date?lang=&rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels/:channel/schedule/:date"

querystring = {"lang":"","rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channel/schedule/:date"

queryString <- list(
  lang = "",
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/channels/:channel/schedule/:date') do |req|
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channel/schedule/:date";

    let querystring = [
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability='

http GET '{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channel/schedule/:date?lang=&rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List all the channels.

{{baseUrl}}/channels

QUERY PARAMS

lang

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/channels?lang=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/channels" {:query-params {:lang ""}})

require "http/client"

url = "{{baseUrl}}/channels?lang="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/channels?lang="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels?lang=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels?lang="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/channels?lang= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/channels?lang=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels?lang="))
    .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}}/channels?lang=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/channels?lang=")
  .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}}/channels?lang=');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/channels', params: {lang: ''}};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels?lang=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/channels?lang=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels?lang=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels?lang=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/channels', qs: {lang: ''}};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/channels');

req.query({
  lang: ''
});

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}}/channels', params: {lang: ''}};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels?lang=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/channels?lang="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/channels?lang=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels?lang=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/channels?lang=');

echo $response->getBody();

setUrl('{{baseUrl}}/channels');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels?lang=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels?lang=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/channels?lang=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels"

querystring = {"lang":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels"

queryString <- list(lang = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels?lang=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/channels') do |req|
  req.params['lang'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels";

    let querystring = [
        ("lang", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/channels?lang='

http GET '{{baseUrl}}/channels?lang='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/channels?lang='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels?lang=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List the highlights for a channel.

{{baseUrl}}/channels/:channel/highlights

QUERY PARAMS

lang

rights

availability

channel

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/channels/:channel/highlights" {:query-params {:lang ""
                                                                                       :rights ""
                                                                                       :availability ""}})

require "http/client"

url = "{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/channels/:channel/highlights?lang=&rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability="))
    .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}}/channels/:channel/highlights?lang=&rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=")
  .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}}/channels/:channel/highlights?lang=&rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/channels/:channel/highlights',
  params: {lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:channel/highlights?lang=&rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/channels/:channel/highlights',
  qs: {lang: '', rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/channels/:channel/highlights');

req.query({
  lang: '',
  rights: '',
  availability: ''
});

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}}/channels/:channel/highlights',
  params: {lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channel/highlights');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => '',
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels/:channel/highlights');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => '',
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/channels/:channel/highlights?lang=&rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels/:channel/highlights"

querystring = {"lang":"","rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channel/highlights"

queryString <- list(
  lang = "",
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/channels/:channel/highlights') do |req|
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channel/highlights";

    let querystring = [
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability='

http GET '{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channel/highlights?lang=&rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Child episodes for a given programme pid.

{{baseUrl}}/programmes/:pid/episodes

QUERY PARAMS

rights

availability

initial_child_count

pid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/programmes/:pid/episodes" {:query-params {:rights ""
                                                                                   :availability ""
                                                                                   :initial_child_count ""}})

require "http/client"

url = "{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/programmes/:pid/episodes?rights=&availability=&initial_child_count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count="))
    .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}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=")
  .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}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/programmes/:pid/episodes',
  params: {rights: '', availability: '', initial_child_count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/programmes/:pid/episodes?rights=&availability=&initial_child_count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/programmes/:pid/episodes',
  qs: {rights: '', availability: '', initial_child_count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/programmes/:pid/episodes');

req.query({
  rights: '',
  availability: '',
  initial_child_count: ''
});

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}}/programmes/:pid/episodes',
  params: {rights: '', availability: '', initial_child_count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=');

echo $response->getBody();

setUrl('{{baseUrl}}/programmes/:pid/episodes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'availability' => '',
  'initial_child_count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/programmes/:pid/episodes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'availability' => '',
  'initial_child_count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/programmes/:pid/episodes?rights=&availability=&initial_child_count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/programmes/:pid/episodes"

querystring = {"rights":"","availability":"","initial_child_count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/programmes/:pid/episodes"

queryString <- list(
  rights = "",
  availability = "",
  initial_child_count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/programmes/:pid/episodes') do |req|
  req.params['rights'] = ''
  req.params['availability'] = ''
  req.params['initial_child_count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/programmes/:pid/episodes";

    let querystring = [
        ("rights", ""),
        ("availability", ""),
        ("initial_child_count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count='

http GET '{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/programmes/:pid/episodes?rights=&availability=&initial_child_count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Episode for a given pid.

{{baseUrl}}/episodes/:pid

QUERY PARAMS

rights

availability

pid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/episodes/:pid?rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/episodes/:pid" {:query-params {:rights ""
                                                                        :availability ""}})

require "http/client"

url = "{{baseUrl}}/episodes/:pid?rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/episodes/:pid?rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/episodes/:pid?rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/episodes/:pid?rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/episodes/:pid?rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/episodes/:pid?rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/episodes/:pid?rights=&availability="))
    .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}}/episodes/:pid?rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/episodes/:pid?rights=&availability=")
  .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}}/episodes/:pid?rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/episodes/:pid?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/episodes/:pid?rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/episodes/:pid?rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/episodes/:pid?rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid',
  qs: {rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/episodes/:pid');

req.query({
  rights: '',
  availability: ''
});

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}}/episodes/:pid',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/episodes/:pid?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/episodes/:pid?rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/episodes/:pid?rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/episodes/:pid?rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/episodes/:pid?rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/episodes/:pid');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/episodes/:pid');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/episodes/:pid?rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/episodes/:pid?rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/episodes/:pid?rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/episodes/:pid"

querystring = {"rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/episodes/:pid"

queryString <- list(
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/episodes/:pid?rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/episodes/:pid') do |req|
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/episodes/:pid";

    let querystring = [
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/episodes/:pid?rights=&availability='

http GET '{{baseUrl}}/episodes/:pid?rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/episodes/:pid?rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/episodes/:pid?rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get Clips

{{baseUrl}}/clips/:pid

QUERY PARAMS

rights

availability

pid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clips/:pid?rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/clips/:pid" {:query-params {:rights ""
                                                                     :availability ""}})

require "http/client"

url = "{{baseUrl}}/clips/:pid?rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/clips/:pid?rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clips/:pid?rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clips/:pid?rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/clips/:pid?rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/clips/:pid?rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clips/:pid?rights=&availability="))
    .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}}/clips/:pid?rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/clips/:pid?rights=&availability=")
  .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}}/clips/:pid?rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clips/:pid',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clips/:pid?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clips/:pid?rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clips/:pid?rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clips/:pid?rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clips/:pid',
  qs: {rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clips/:pid');

req.query({
  rights: '',
  availability: ''
});

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}}/clips/:pid',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clips/:pid?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clips/:pid?rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clips/:pid?rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clips/:pid?rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/clips/:pid?rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/clips/:pid');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/clips/:pid');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clips/:pid?rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clips/:pid?rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/clips/:pid?rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clips/:pid"

querystring = {"rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clips/:pid"

queryString <- list(
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clips/:pid?rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/clips/:pid') do |req|
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clips/:pid";

    let querystring = [
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/clips/:pid?rights=&availability='

http GET '{{baseUrl}}/clips/:pid?rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/clips/:pid?rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clips/:pid?rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get Follow-ups (post-rolls)

{{baseUrl}}/episodes/:pid/postrolls

QUERY PARAMS

rights

availability

pid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/episodes/:pid/postrolls" {:query-params {:rights ""
                                                                                  :availability ""}})

require "http/client"

url = "{{baseUrl}}/episodes/:pid/postrolls?rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/episodes/:pid/postrolls?rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/episodes/:pid/postrolls?rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/episodes/:pid/postrolls?rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/episodes/:pid/postrolls?rights=&availability="))
    .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}}/episodes/:pid/postrolls?rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=")
  .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}}/episodes/:pid/postrolls?rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid/postrolls',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/episodes/:pid/postrolls?rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid/postrolls',
  qs: {rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/episodes/:pid/postrolls');

req.query({
  rights: '',
  availability: ''
});

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}}/episodes/:pid/postrolls',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/episodes/:pid/postrolls?rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/episodes/:pid/postrolls');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/episodes/:pid/postrolls');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/episodes/:pid/postrolls?rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/episodes/:pid/postrolls"

querystring = {"rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/episodes/:pid/postrolls"

queryString <- list(
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/episodes/:pid/postrolls') do |req|
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/episodes/:pid/postrolls";

    let querystring = [
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/episodes/:pid/postrolls?rights=&availability='

http GET '{{baseUrl}}/episodes/:pid/postrolls?rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/episodes/:pid/postrolls?rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/episodes/:pid/postrolls?rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get Onward Journey

{{baseUrl}}/episodes/:pid/next

QUERY PARAMS

rights

availability

pid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/episodes/:pid/next?rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/episodes/:pid/next" {:query-params {:rights ""
                                                                             :availability ""}})

require "http/client"

url = "{{baseUrl}}/episodes/:pid/next?rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/episodes/:pid/next?rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/episodes/:pid/next?rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/episodes/:pid/next?rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/episodes/:pid/next?rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/episodes/:pid/next?rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/episodes/:pid/next?rights=&availability="))
    .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}}/episodes/:pid/next?rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/episodes/:pid/next?rights=&availability=")
  .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}}/episodes/:pid/next?rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid/next',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/episodes/:pid/next?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/episodes/:pid/next?rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/episodes/:pid/next?rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/episodes/:pid/next?rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid/next',
  qs: {rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/episodes/:pid/next');

req.query({
  rights: '',
  availability: ''
});

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}}/episodes/:pid/next',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/episodes/:pid/next?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/episodes/:pid/next?rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/episodes/:pid/next?rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/episodes/:pid/next?rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/episodes/:pid/next?rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/episodes/:pid/next');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/episodes/:pid/next');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/episodes/:pid/next?rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/episodes/:pid/next?rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/episodes/:pid/next?rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/episodes/:pid/next"

querystring = {"rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/episodes/:pid/next"

queryString <- list(
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/episodes/:pid/next?rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/episodes/:pid/next') do |req|
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/episodes/:pid/next";

    let querystring = [
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/episodes/:pid/next?rights=&availability='

http GET '{{baseUrl}}/episodes/:pid/next?rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/episodes/:pid/next?rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/episodes/:pid/next?rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get Trailers (pre-rolls)

{{baseUrl}}/episodes/:pid/prerolls

QUERY PARAMS

rights

availability

pid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/episodes/:pid/prerolls" {:query-params {:rights ""
                                                                                 :availability ""}})

require "http/client"

url = "{{baseUrl}}/episodes/:pid/prerolls?rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/episodes/:pid/prerolls?rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/episodes/:pid/prerolls?rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/episodes/:pid/prerolls?rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/episodes/:pid/prerolls?rights=&availability="))
    .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}}/episodes/:pid/prerolls?rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=")
  .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}}/episodes/:pid/prerolls?rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid/prerolls',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/episodes/:pid/prerolls?rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid/prerolls',
  qs: {rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/episodes/:pid/prerolls');

req.query({
  rights: '',
  availability: ''
});

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}}/episodes/:pid/prerolls',
  params: {rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/episodes/:pid/prerolls?rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/episodes/:pid/prerolls');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/episodes/:pid/prerolls');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/episodes/:pid/prerolls?rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/episodes/:pid/prerolls"

querystring = {"rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/episodes/:pid/prerolls"

queryString <- list(
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/episodes/:pid/prerolls') do |req|
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/episodes/:pid/prerolls";

    let querystring = [
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/episodes/:pid/prerolls?rights=&availability='

http GET '{{baseUrl}}/episodes/:pid/prerolls?rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/episodes/:pid/prerolls?rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/episodes/:pid/prerolls?rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get episodes by group, brand or series

{{baseUrl}}/groups/:pid/episodes

QUERY PARAMS

rights

page

per_page

initial_child_count

sort

sort_direction

availability

pid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/groups/:pid/episodes" {:query-params {:rights ""
                                                                               :page ""
                                                                               :per_page ""
                                                                               :initial_child_count ""
                                                                               :sort ""
                                                                               :sort_direction ""
                                                                               :availability ""}})

require "http/client"

url = "{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="))
    .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}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .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}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups/:pid/episodes',
  params: {
    rights: '',
    page: '',
    per_page: '',
    initial_child_count: '',
    sort: '',
    sort_direction: '',
    availability: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups/:pid/episodes',
  qs: {
    rights: '',
    page: '',
    per_page: '',
    initial_child_count: '',
    sort: '',
    sort_direction: '',
    availability: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/groups/:pid/episodes');

req.query({
  rights: '',
  page: '',
  per_page: '',
  initial_child_count: '',
  sort: '',
  sort_direction: '',
  availability: ''
});

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}}/groups/:pid/episodes',
  params: {
    rights: '',
    page: '',
    per_page: '',
    initial_child_count: '',
    sort: '',
    sort_direction: '',
    availability: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/groups/:pid/episodes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'page' => '',
  'per_page' => '',
  'initial_child_count' => '',
  'sort' => '',
  'sort_direction' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/groups/:pid/episodes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'page' => '',
  'per_page' => '',
  'initial_child_count' => '',
  'sort' => '',
  'sort_direction' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/groups/:pid/episodes"

querystring = {"rights":"","page":"","per_page":"","initial_child_count":"","sort":"","sort_direction":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/:pid/episodes"

queryString <- list(
  rights = "",
  page = "",
  per_page = "",
  initial_child_count = "",
  sort = "",
  sort_direction = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/groups/:pid/episodes') do |req|
  req.params['rights'] = ''
  req.params['page'] = ''
  req.params['per_page'] = ''
  req.params['initial_child_count'] = ''
  req.params['sort'] = ''
  req.params['sort_direction'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/:pid/episodes";

    let querystring = [
        ("rights", ""),
        ("page", ""),
        ("per_page", ""),
        ("initial_child_count", ""),
        ("sort", ""),
        ("sort_direction", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability='

http GET '{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/:pid/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get programme recommendations

{{baseUrl}}/episodes/:pid/recommendations

QUERY PARAMS

rights

availability

page

per_page

pid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/episodes/:pid/recommendations" {:query-params {:rights ""
                                                                                        :availability ""
                                                                                        :page ""
                                                                                        :per_page ""}})

require "http/client"

url = "{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/episodes/:pid/recommendations?rights=&availability=&page=&per_page= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page="))
    .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}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=")
  .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}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid/recommendations',
  params: {rights: '', availability: '', page: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/episodes/:pid/recommendations?rights=&availability=&page=&per_page=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:pid/recommendations',
  qs: {rights: '', availability: '', page: '', per_page: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/episodes/:pid/recommendations');

req.query({
  rights: '',
  availability: '',
  page: '',
  per_page: ''
});

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}}/episodes/:pid/recommendations',
  params: {rights: '', availability: '', page: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=');

echo $response->getBody();

setUrl('{{baseUrl}}/episodes/:pid/recommendations');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'availability' => '',
  'page' => '',
  'per_page' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/episodes/:pid/recommendations');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'availability' => '',
  'page' => '',
  'per_page' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/episodes/:pid/recommendations?rights=&availability=&page=&per_page=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/episodes/:pid/recommendations"

querystring = {"rights":"","availability":"","page":"","per_page":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/episodes/:pid/recommendations"

queryString <- list(
  rights = "",
  availability = "",
  page = "",
  per_page = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/episodes/:pid/recommendations') do |req|
  req.params['rights'] = ''
  req.params['availability'] = ''
  req.params['page'] = ''
  req.params['per_page'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/episodes/:pid/recommendations";

    let querystring = [
        ("rights", ""),
        ("availability", ""),
        ("page", ""),
        ("per_page", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page='

http GET '{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/episodes/:pid/recommendations?rights=&availability=&page=&per_page=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get programmes popular

{{baseUrl}}/groups/popular/episodes

QUERY PARAMS

rights

page

per_page

initial_child_count

sort

sort_direction

availability

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/groups/popular/episodes" {:query-params {:rights ""
                                                                                  :page ""
                                                                                  :per_page ""
                                                                                  :initial_child_count ""
                                                                                  :sort ""
                                                                                  :sort_direction ""
                                                                                  :availability ""}})

require "http/client"

url = "{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="))
    .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}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .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}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups/popular/episodes',
  params: {
    rights: '',
    page: '',
    per_page: '',
    initial_child_count: '',
    sort: '',
    sort_direction: '',
    availability: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/groups/popular/episodes',
  qs: {
    rights: '',
    page: '',
    per_page: '',
    initial_child_count: '',
    sort: '',
    sort_direction: '',
    availability: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/groups/popular/episodes');

req.query({
  rights: '',
  page: '',
  per_page: '',
  initial_child_count: '',
  sort: '',
  sort_direction: '',
  availability: ''
});

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}}/groups/popular/episodes',
  params: {
    rights: '',
    page: '',
    per_page: '',
    initial_child_count: '',
    sort: '',
    sort_direction: '',
    availability: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/groups/popular/episodes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'page' => '',
  'per_page' => '',
  'initial_child_count' => '',
  'sort' => '',
  'sort_direction' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/groups/popular/episodes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'page' => '',
  'per_page' => '',
  'initial_child_count' => '',
  'sort' => '',
  'sort_direction' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/groups/popular/episodes"

querystring = {"rights":"","page":"","per_page":"","initial_child_count":"","sort":"","sort_direction":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/groups/popular/episodes"

queryString <- list(
  rights = "",
  page = "",
  per_page = "",
  initial_child_count = "",
  sort = "",
  sort_direction = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/groups/popular/episodes') do |req|
  req.params['rights'] = ''
  req.params['page'] = ''
  req.params['per_page'] = ''
  req.params['initial_child_count'] = ''
  req.params['sort'] = ''
  req.params['sort_direction'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/groups/popular/episodes";

    let querystring = [
        ("rights", ""),
        ("page", ""),
        ("per_page", ""),
        ("initial_child_count", ""),
        ("sort", ""),
        ("sort_direction", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability='

http GET '{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/groups/popular/episodes?rights=&page=&per_page=&initial_child_count=&sort=&sort_direction=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List all the episodes for a category.

{{baseUrl}}/categories/:category/episodes

QUERY PARAMS

lang

rights

availability

page

per_page

category

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/categories/:category/episodes" {:query-params {:lang ""
                                                                                        :rights ""
                                                                                        :availability ""
                                                                                        :page ""
                                                                                        :per_page ""}})

require "http/client"

url = "{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/categories/:category/episodes?lang=&rights=&availability=&page=&per_page= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page="))
    .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/:category/episodes?lang=&rights=&availability=&page=&per_page=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=")
  .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/:category/episodes?lang=&rights=&availability=&page=&per_page=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories/:category/episodes',
  params: {lang: '', rights: '', availability: '', page: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories/:category/episodes',
  qs: {lang: '', rights: '', availability: '', page: '', per_page: ''}
};

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/:category/episodes');

req.query({
  lang: '',
  rights: '',
  availability: '',
  page: '',
  per_page: ''
});

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/:category/episodes',
  params: {lang: '', rights: '', availability: '', page: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=');

echo $response->getBody();

setUrl('{{baseUrl}}/categories/:category/episodes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => '',
  'rights' => '',
  'availability' => '',
  'page' => '',
  'per_page' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/categories/:category/episodes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => '',
  'rights' => '',
  'availability' => '',
  'page' => '',
  'per_page' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/categories/:category/episodes"

querystring = {"lang":"","rights":"","availability":"","page":"","per_page":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories/:category/episodes"

queryString <- list(
  lang = "",
  rights = "",
  availability = "",
  page = "",
  per_page = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/categories/:category/episodes') do |req|
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
  req.params['page'] = ''
  req.params['per_page'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/categories/:category/episodes";

    let querystring = [
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
        ("page", ""),
        ("per_page", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page='

http GET '{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/categories/:category/episodes?lang=&rights=&availability=&page=&per_page=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get schema

{{baseUrl}}/schema/ibl.json

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/schema/ibl.json");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/schema/ibl.json")

require "http/client"

url = "{{baseUrl}}/schema/ibl.json"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/schema/ibl.json"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/schema/ibl.json");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/schema/ibl.json"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/schema/ibl.json HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/schema/ibl.json")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/schema/ibl.json"))
    .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}}/schema/ibl.json")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/schema/ibl.json")
  .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}}/schema/ibl.json');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/schema/ibl.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/schema/ibl.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/schema/ibl.json',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/schema/ibl.json")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/schema/ibl.json',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/schema/ibl.json'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/schema/ibl.json');

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}}/schema/ibl.json'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/schema/ibl.json';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/schema/ibl.json"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/schema/ibl.json" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/schema/ibl.json",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/schema/ibl.json');

echo $response->getBody();

setUrl('{{baseUrl}}/schema/ibl.json');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/schema/ibl.json');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/schema/ibl.json' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/schema/ibl.json' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/schema/ibl.json")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/schema/ibl.json"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/schema/ibl.json"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/schema/ibl.json")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/schema/ibl.json') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/schema/ibl.json";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/schema/ibl.json

http GET {{baseUrl}}/schema/ibl.json

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/schema/ibl.json

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/schema/ibl.json")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get status

{{baseUrl}}/status

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/status")

require "http/client"

url = "{{baseUrl}}/status"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/status"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/status"))
    .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}}/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/status")
  .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}}/status');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/status',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/status'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/status');

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}}/status'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/status';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/status"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/status",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/status');

echo $response->getBody();

setUrl('{{baseUrl}}/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/status' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/status' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/status")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/status

http GET {{baseUrl}}/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get broadcasts by channel

{{baseUrl}}/channels/:channel/broadcasts

QUERY PARAMS

lang

rights

availability

per_page

channel

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/channels/:channel/broadcasts" {:query-params {:lang ""
                                                                                       :rights ""
                                                                                       :availability ""
                                                                                       :per_page ""}})

require "http/client"

url = "{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/channels/:channel/broadcasts?lang=&rights=&availability=&per_page= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page="))
    .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}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=")
  .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}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/channels/:channel/broadcasts',
  params: {lang: '', rights: '', availability: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/channels/:channel/broadcasts',
  qs: {lang: '', rights: '', availability: '', per_page: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/channels/:channel/broadcasts');

req.query({
  lang: '',
  rights: '',
  availability: '',
  per_page: ''
});

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}}/channels/:channel/broadcasts',
  params: {lang: '', rights: '', availability: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channel/broadcasts');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => '',
  'rights' => '',
  'availability' => '',
  'per_page' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels/:channel/broadcasts');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => '',
  'rights' => '',
  'availability' => '',
  'per_page' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels/:channel/broadcasts"

querystring = {"lang":"","rights":"","availability":"","per_page":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channel/broadcasts"

queryString <- list(
  lang = "",
  rights = "",
  availability = "",
  per_page = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/channels/:channel/broadcasts') do |req|
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
  req.params['per_page'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channel/broadcasts";

    let querystring = [
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
        ("per_page", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page='

http GET '{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channel/broadcasts?lang=&rights=&availability=&per_page=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get programme highlights

{{baseUrl}}/home/highlights

QUERY PARAMS

lang

rights

availability

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/home/highlights?lang=&rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/home/highlights" {:query-params {:lang ""
                                                                          :rights ""
                                                                          :availability ""}})

require "http/client"

url = "{{baseUrl}}/home/highlights?lang=&rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/home/highlights?lang=&rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/home/highlights?lang=&rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/home/highlights?lang=&rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/home/highlights?lang=&rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/home/highlights?lang=&rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/home/highlights?lang=&rights=&availability="))
    .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}}/home/highlights?lang=&rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/home/highlights?lang=&rights=&availability=")
  .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}}/home/highlights?lang=&rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/home/highlights',
  params: {lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/home/highlights?lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/home/highlights?lang=&rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/home/highlights?lang=&rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/home/highlights?lang=&rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/home/highlights',
  qs: {lang: '', rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/home/highlights');

req.query({
  lang: '',
  rights: '',
  availability: ''
});

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}}/home/highlights',
  params: {lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/home/highlights?lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/home/highlights?lang=&rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/home/highlights?lang=&rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/home/highlights?lang=&rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/home/highlights?lang=&rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/home/highlights');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => '',
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/home/highlights');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => '',
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/home/highlights?lang=&rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/home/highlights?lang=&rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/home/highlights?lang=&rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/home/highlights"

querystring = {"lang":"","rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/home/highlights"

queryString <- list(
  lang = "",
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/home/highlights?lang=&rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/home/highlights') do |req|
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/home/highlights";

    let querystring = [
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/home/highlights?lang=&rights=&availability='

http GET '{{baseUrl}}/home/highlights?lang=&rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/home/highlights?lang=&rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/home/highlights?lang=&rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get programmes by channel

{{baseUrl}}/channels/:channel/programmes

QUERY PARAMS

lang

rights

availability

page

per_page

channel

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/channels/:channel/programmes" {:query-params {:lang ""
                                                                                       :rights ""
                                                                                       :availability ""
                                                                                       :page ""
                                                                                       :per_page ""}})

require "http/client"

url = "{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page="))
    .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}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=")
  .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}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/channels/:channel/programmes',
  params: {lang: '', rights: '', availability: '', page: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/channels/:channel/programmes',
  qs: {lang: '', rights: '', availability: '', page: '', per_page: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/channels/:channel/programmes');

req.query({
  lang: '',
  rights: '',
  availability: '',
  page: '',
  per_page: ''
});

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}}/channels/:channel/programmes',
  params: {lang: '', rights: '', availability: '', page: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=');

echo $response->getBody();

setUrl('{{baseUrl}}/channels/:channel/programmes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => '',
  'rights' => '',
  'availability' => '',
  'page' => '',
  'per_page' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/channels/:channel/programmes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => '',
  'rights' => '',
  'availability' => '',
  'page' => '',
  'per_page' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/channels/:channel/programmes"

querystring = {"lang":"","rights":"","availability":"","page":"","per_page":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/channels/:channel/programmes"

queryString <- list(
  lang = "",
  rights = "",
  availability = "",
  page = "",
  per_page = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/channels/:channel/programmes') do |req|
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
  req.params['page'] = ''
  req.params['per_page'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/channels/:channel/programmes";

    let querystring = [
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
        ("page", ""),
        ("per_page", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page='

http GET '{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/channels/:channel/programmes?lang=&rights=&availability=&page=&per_page=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List all the programmes for a category.

{{baseUrl}}/categories/:category/programmes

QUERY PARAMS

lang

rights

availability

page

per_page

category

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/categories/:category/programmes" {:query-params {:lang ""
                                                                                          :rights ""
                                                                                          :availability ""
                                                                                          :page ""
                                                                                          :per_page ""}})

require "http/client"

url = "{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/categories/:category/programmes?lang=&rights=&availability=&page=&per_page= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page="))
    .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/:category/programmes?lang=&rights=&availability=&page=&per_page=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=")
  .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/:category/programmes?lang=&rights=&availability=&page=&per_page=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories/:category/programmes',
  params: {lang: '', rights: '', availability: '', page: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories/:category/programmes',
  qs: {lang: '', rights: '', availability: '', page: '', per_page: ''}
};

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/:category/programmes');

req.query({
  lang: '',
  rights: '',
  availability: '',
  page: '',
  per_page: ''
});

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/:category/programmes',
  params: {lang: '', rights: '', availability: '', page: '', per_page: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=');

echo $response->getBody();

setUrl('{{baseUrl}}/categories/:category/programmes');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => '',
  'rights' => '',
  'availability' => '',
  'page' => '',
  'per_page' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/categories/:category/programmes');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => '',
  'rights' => '',
  'availability' => '',
  'page' => '',
  'per_page' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/categories/:category/programmes"

querystring = {"lang":"","rights":"","availability":"","page":"","per_page":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories/:category/programmes"

queryString <- list(
  lang = "",
  rights = "",
  availability = "",
  page = "",
  per_page = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/categories/:category/programmes') do |req|
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
  req.params['page'] = ''
  req.params['per_page'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/categories/:category/programmes";

    let querystring = [
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
        ("page", ""),
        ("per_page", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page='

http GET '{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/categories/:category/programmes?lang=&rights=&availability=&page=&per_page=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List the highlights for a category.

{{baseUrl}}/categories/:category/highlights

QUERY PARAMS

lang

rights

availability

category

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/categories/:category/highlights" {:query-params {:lang ""
                                                                                          :rights ""
                                                                                          :availability ""}})

require "http/client"

url = "{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/categories/:category/highlights?lang=&rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability="))
    .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/:category/highlights?lang=&rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=")
  .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/:category/highlights?lang=&rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories/:category/highlights',
  params: {lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/categories/:category/highlights?lang=&rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/categories/:category/highlights',
  qs: {lang: '', rights: '', availability: ''}
};

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/:category/highlights');

req.query({
  lang: '',
  rights: '',
  availability: ''
});

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/:category/highlights',
  params: {lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/categories/:category/highlights');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => '',
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/categories/:category/highlights');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => '',
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/categories/:category/highlights?lang=&rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/categories/:category/highlights"

querystring = {"lang":"","rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/categories/:category/highlights"

queryString <- list(
  lang = "",
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/categories/:category/highlights') do |req|
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/categories/:category/highlights";

    let querystring = [
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability='

http GET '{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/categories/:category/highlights?lang=&rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Programme for a given pid.

{{baseUrl}}/programmes/:pid

QUERY PARAMS

rights

availability

initial_child_count

pid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/programmes/:pid" {:query-params {:rights ""
                                                                          :availability ""
                                                                          :initial_child_count ""}})

require "http/client"

url = "{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/programmes/:pid?rights=&availability=&initial_child_count= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count="))
    .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}}/programmes/:pid?rights=&availability=&initial_child_count=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=")
  .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}}/programmes/:pid?rights=&availability=&initial_child_count=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/programmes/:pid',
  params: {rights: '', availability: '', initial_child_count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/programmes/:pid?rights=&availability=&initial_child_count=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/programmes/:pid',
  qs: {rights: '', availability: '', initial_child_count: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/programmes/:pid');

req.query({
  rights: '',
  availability: '',
  initial_child_count: ''
});

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}}/programmes/:pid',
  params: {rights: '', availability: '', initial_child_count: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=');

echo $response->getBody();

setUrl('{{baseUrl}}/programmes/:pid');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'rights' => '',
  'availability' => '',
  'initial_child_count' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/programmes/:pid');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'rights' => '',
  'availability' => '',
  'initial_child_count' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/programmes/:pid?rights=&availability=&initial_child_count=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/programmes/:pid"

querystring = {"rights":"","availability":"","initial_child_count":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/programmes/:pid"

queryString <- list(
  rights = "",
  availability = "",
  initial_child_count = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/programmes/:pid') do |req|
  req.params['rights'] = ''
  req.params['availability'] = ''
  req.params['initial_child_count'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/programmes/:pid";

    let querystring = [
        ("rights", ""),
        ("availability", ""),
        ("initial_child_count", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count='

http GET '{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/programmes/:pid?rights=&availability=&initial_child_count=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET List all regions

{{baseUrl}}/regions

QUERY PARAMS

lang

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/regions?lang=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/regions" {:query-params {:lang ""}})

require "http/client"

url = "{{baseUrl}}/regions?lang="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/regions?lang="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/regions?lang=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/regions?lang="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/regions?lang= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/regions?lang=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/regions?lang="))
    .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}}/regions?lang=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/regions?lang=")
  .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}}/regions?lang=');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/regions', params: {lang: ''}};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/regions?lang=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/regions?lang=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/regions?lang=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/regions?lang=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/regions', qs: {lang: ''}};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/regions');

req.query({
  lang: ''
});

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}}/regions', params: {lang: ''}};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/regions?lang=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/regions?lang="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/regions?lang=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/regions?lang=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/regions?lang=');

echo $response->getBody();

setUrl('{{baseUrl}}/regions');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'lang' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/regions');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'lang' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/regions?lang=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/regions?lang=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/regions?lang=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/regions"

querystring = {"lang":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/regions"

queryString <- list(lang = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/regions?lang=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/regions') do |req|
  req.params['lang'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/regions";

    let querystring = [
        ("lang", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/regions?lang='

http GET '{{baseUrl}}/regions?lang='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/regions?lang='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/regions?lang=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Search-suggest

{{baseUrl}}/search-suggest

QUERY PARAMS

lang

rights

availability

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/search-suggest" {:query-params {:q ""
                                                                         :lang ""
                                                                         :rights ""
                                                                         :availability ""}})

require "http/client"

url = "{{baseUrl}}/search-suggest?q=&lang=&rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/search-suggest?q=&lang=&rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/search-suggest?q=&lang=&rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/search-suggest?q=&lang=&rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/search-suggest?q=&lang=&rights=&availability="))
    .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}}/search-suggest?q=&lang=&rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=")
  .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}}/search-suggest?q=&lang=&rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/search-suggest',
  params: {q: '', lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/search-suggest?q=&lang=&rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/search-suggest',
  qs: {q: '', lang: '', rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/search-suggest');

req.query({
  q: '',
  lang: '',
  rights: '',
  availability: ''
});

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}}/search-suggest',
  params: {q: '', lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/search-suggest?q=&lang=&rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/search-suggest');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'q' => '',
  'lang' => '',
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/search-suggest');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'q' => '',
  'lang' => '',
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/search-suggest?q=&lang=&rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/search-suggest"

querystring = {"q":"","lang":"","rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/search-suggest"

queryString <- list(
  q = "",
  lang = "",
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/search-suggest') do |req|
  req.params['q'] = ''
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/search-suggest";

    let querystring = [
        ("q", ""),
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/search-suggest?q=&lang=&rights=&availability='

http GET '{{baseUrl}}/search-suggest?q=&lang=&rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/search-suggest?q=&lang=&rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/search-suggest?q=&lang=&rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Search

{{baseUrl}}/search

QUERY PARAMS

lang

rights

availability

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/search?q=&lang=&rights=&availability=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/search" {:query-params {:q ""
                                                                 :lang ""
                                                                 :rights ""
                                                                 :availability ""}})

require "http/client"

url = "{{baseUrl}}/search?q=&lang=&rights=&availability="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/search?q=&lang=&rights=&availability="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/search?q=&lang=&rights=&availability=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/search?q=&lang=&rights=&availability="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/search?q=&lang=&rights=&availability= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/search?q=&lang=&rights=&availability=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/search?q=&lang=&rights=&availability="))
    .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}}/search?q=&lang=&rights=&availability=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/search?q=&lang=&rights=&availability=")
  .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}}/search?q=&lang=&rights=&availability=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/search',
  params: {q: '', lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/search?q=&lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/search?q=&lang=&rights=&availability=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/search?q=&lang=&rights=&availability=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/search?q=&lang=&rights=&availability=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/search',
  qs: {q: '', lang: '', rights: '', availability: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/search');

req.query({
  q: '',
  lang: '',
  rights: '',
  availability: ''
});

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}}/search',
  params: {q: '', lang: '', rights: '', availability: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/search?q=&lang=&rights=&availability=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/search?q=&lang=&rights=&availability="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/search?q=&lang=&rights=&availability=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/search?q=&lang=&rights=&availability=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/search?q=&lang=&rights=&availability=');

echo $response->getBody();

setUrl('{{baseUrl}}/search');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'q' => '',
  'lang' => '',
  'rights' => '',
  'availability' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/search');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'q' => '',
  'lang' => '',
  'rights' => '',
  'availability' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/search?q=&lang=&rights=&availability=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/search?q=&lang=&rights=&availability=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/search?q=&lang=&rights=&availability=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/search"

querystring = {"q":"","lang":"","rights":"","availability":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/search"

queryString <- list(
  q = "",
  lang = "",
  rights = "",
  availability = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/search?q=&lang=&rights=&availability=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/search') do |req|
  req.params['q'] = ''
  req.params['lang'] = ''
  req.params['rights'] = ''
  req.params['availability'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/search";

    let querystring = [
        ("q", ""),
        ("lang", ""),
        ("rights", ""),
        ("availability", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/search?q=&lang=&rights=&availability='

http GET '{{baseUrl}}/search?q=&lang=&rights=&availability='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/search?q=&lang=&rights=&availability='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/search?q=&lang=&rights=&availability=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get user store purchases

{{baseUrl}}/user/purchases

QUERY PARAMS

identity_cookie

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/purchases?identity_cookie=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/purchases" {:query-params {:identity_cookie ""}})

require "http/client"

url = "{{baseUrl}}/user/purchases?identity_cookie="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/user/purchases?identity_cookie="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/purchases?identity_cookie=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/purchases?identity_cookie="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/purchases?identity_cookie= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/purchases?identity_cookie=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/purchases?identity_cookie="))
    .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}}/user/purchases?identity_cookie=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/purchases?identity_cookie=")
  .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}}/user/purchases?identity_cookie=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/purchases',
  params: {identity_cookie: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/purchases?identity_cookie=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/purchases?identity_cookie=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/purchases?identity_cookie=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/purchases?identity_cookie=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/purchases',
  qs: {identity_cookie: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/purchases');

req.query({
  identity_cookie: ''
});

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}}/user/purchases',
  params: {identity_cookie: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/purchases?identity_cookie=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/purchases?identity_cookie="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/user/purchases?identity_cookie=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/purchases?identity_cookie=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/purchases?identity_cookie=');

echo $response->getBody();

setUrl('{{baseUrl}}/user/purchases');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'identity_cookie' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/purchases');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'identity_cookie' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/purchases?identity_cookie=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/purchases?identity_cookie=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/user/purchases?identity_cookie=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/purchases"

querystring = {"identity_cookie":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/purchases"

queryString <- list(identity_cookie = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/purchases?identity_cookie=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/purchases') do |req|
  req.params['identity_cookie'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/purchases";

    let querystring = [
        ("identity_cookie", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/user/purchases?identity_cookie='

http GET '{{baseUrl}}/user/purchases?identity_cookie='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/user/purchases?identity_cookie='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/purchases?identity_cookie=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get user store recommendations

{{baseUrl}}/user/recommendations

QUERY PARAMS

identity_cookie

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/recommendations?identity_cookie=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/recommendations" {:query-params {:identity_cookie ""}})

require "http/client"

url = "{{baseUrl}}/user/recommendations?identity_cookie="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/user/recommendations?identity_cookie="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/recommendations?identity_cookie=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/recommendations?identity_cookie="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/recommendations?identity_cookie= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/recommendations?identity_cookie=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/recommendations?identity_cookie="))
    .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}}/user/recommendations?identity_cookie=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/recommendations?identity_cookie=")
  .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}}/user/recommendations?identity_cookie=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/recommendations',
  params: {identity_cookie: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/recommendations?identity_cookie=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/recommendations?identity_cookie=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/recommendations?identity_cookie=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/recommendations?identity_cookie=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/recommendations',
  qs: {identity_cookie: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/recommendations');

req.query({
  identity_cookie: ''
});

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}}/user/recommendations',
  params: {identity_cookie: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/recommendations?identity_cookie=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/recommendations?identity_cookie="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/user/recommendations?identity_cookie=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/recommendations?identity_cookie=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/recommendations?identity_cookie=');

echo $response->getBody();

setUrl('{{baseUrl}}/user/recommendations');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'identity_cookie' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/recommendations');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'identity_cookie' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/recommendations?identity_cookie=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/recommendations?identity_cookie=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/user/recommendations?identity_cookie=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/recommendations"

querystring = {"identity_cookie":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/recommendations"

queryString <- list(identity_cookie = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/recommendations?identity_cookie=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/recommendations') do |req|
  req.params['identity_cookie'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/recommendations";

    let querystring = [
        ("identity_cookie", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/user/recommendations?identity_cookie='

http GET '{{baseUrl}}/user/recommendations?identity_cookie='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/user/recommendations?identity_cookie='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/recommendations?identity_cookie=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get user watching

{{baseUrl}}/user/watching

QUERY PARAMS

identity_cookie

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/user/watching?identity_cookie=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/user/watching" {:query-params {:identity_cookie ""}})

require "http/client"

url = "{{baseUrl}}/user/watching?identity_cookie="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/user/watching?identity_cookie="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/user/watching?identity_cookie=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/user/watching?identity_cookie="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/user/watching?identity_cookie= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/user/watching?identity_cookie=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/user/watching?identity_cookie="))
    .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}}/user/watching?identity_cookie=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/user/watching?identity_cookie=")
  .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}}/user/watching?identity_cookie=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/watching',
  params: {identity_cookie: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/user/watching?identity_cookie=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/user/watching?identity_cookie=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/user/watching?identity_cookie=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/user/watching?identity_cookie=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/user/watching',
  qs: {identity_cookie: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/user/watching');

req.query({
  identity_cookie: ''
});

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}}/user/watching',
  params: {identity_cookie: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/user/watching?identity_cookie=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/user/watching?identity_cookie="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/user/watching?identity_cookie=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/user/watching?identity_cookie=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/user/watching?identity_cookie=');

echo $response->getBody();

setUrl('{{baseUrl}}/user/watching');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'identity_cookie' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/user/watching');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'identity_cookie' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/user/watching?identity_cookie=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/user/watching?identity_cookie=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/user/watching?identity_cookie=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/user/watching"

querystring = {"identity_cookie":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/user/watching"

queryString <- list(identity_cookie = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/user/watching?identity_cookie=")

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

request = Net::HTTP::Get.new(url)

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/user/watching') do |req|
  req.params['identity_cookie'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/user/watching";

    let querystring = [
        ("identity_cookie", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/user/watching?identity_cookie='

http GET '{{baseUrl}}/user/watching?identity_cookie='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/user/watching?identity_cookie='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/user/watching?identity_cookie=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()