Listen API: Podcast Search, Directory, and Insights API

POST Batch fetch basic meta data for episodes

{{baseUrl}}/episodes

HEADERS

X-ListenAPI-Key

BODY formUrlEncoded

ids

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/episodes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "ids=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/episodes" {:headers {:x-listenapi-key ""}
                                                     :form-params {:ids ""}})

require "http/client"

url = "{{baseUrl}}/episodes"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ids="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/episodes"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ids", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/episodes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-listenapi-key", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ids=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("ids=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-listenapi-key", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/episodes HTTP/1.1
X-Listenapi-Key: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 4

ids=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/episodes")
  .setHeader("x-listenapi-key", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ids=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/episodes"))
    .header("x-listenapi-key", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ids="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "ids=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/episodes")
  .post(body)
  .addHeader("x-listenapi-key", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/episodes")
  .header("x-listenapi-key", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ids=")
  .asString();

const data = 'ids=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/episodes');
xhr.setRequestHeader('x-listenapi-key', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ids', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/episodes',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/episodes';
const options = {
  method: 'POST',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({ids: ''})
};

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',
  method: 'POST',
  headers: {
    'x-listenapi-key': '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ids: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "ids=")
val request = Request.Builder()
  .url("{{baseUrl}}/episodes")
  .post(body)
  .addHeader("x-listenapi-key", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/episodes',
  headers: {
    'x-listenapi-key': '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

req.write(qs.stringify({ids: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/episodes',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {ids: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/episodes');

req.headers({
  'x-listenapi-key': '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  ids: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('ids', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/episodes',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('ids', '');

const url = '{{baseUrl}}/episodes';
const options = {
  method: 'POST',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"ids=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/episodes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/episodes" in
let headers = Header.add_list (Header.init ()) [
  ("x-listenapi-key", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "ids=" in

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

 "{{baseUrl}}/episodes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "ids=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/episodes', [
  'form_params' => [
    'ids' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/episodes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-listenapi-key' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ids' => ''
]);

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

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

append(new http\QueryString([
  'ids' => ''
]));

$request->setRequestUrl('{{baseUrl}}/episodes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-listenapi-key' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/episodes' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ids='

$headers=@{}
$headers.Add("x-listenapi-key", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/episodes' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ids='

import http.client

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

payload = "ids="

headers = {
    'x-listenapi-key': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/episodes", payload, headers)

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

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

import requests

url = "{{baseUrl}}/episodes"

payload = { "ids": "" }
headers = {
    "x-listenapi-key": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

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

payload <- "ids="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('x-listenapi-key' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/episodes")

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

request = Net::HTTP::Post.new(url)
request["x-listenapi-key"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "ids="

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

require 'faraday'

data = {
  :ids => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/episodes') do |req|
  req.headers['x-listenapi-key'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"ids": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/episodes \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'x-listenapi-key: ' \
  --data ids=

http --form POST {{baseUrl}}/episodes \
  content-type:application/x-www-form-urlencoded \
  x-listenapi-key:'' \
  ids=''

wget --quiet \
  --method POST \
  --header 'x-listenapi-key: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data ids= \
  --output-document \
  - {{baseUrl}}/episodes

import Foundation

let headers = [
  "x-listenapi-key": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "ids=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/episodes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST Batch fetch basic meta data for podcasts

{{baseUrl}}/podcasts

HEADERS

X-ListenAPI-Key

BODY formUrlEncoded

ids

itunes_ids

next_episode_pub_date

rsses

show_latest_episodes

spotify_ids

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/podcasts" {:headers {:x-listenapi-key ""}
                                                     :form-params {:ids ""
                                                                   :itunes_ids ""
                                                                   :next_episode_pub_date ""
                                                                   :rsses ""
                                                                   :show_latest_episodes ""
                                                                   :spotify_ids ""}})

require "http/client"

url = "{{baseUrl}}/podcasts"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/podcasts"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "ids", "" },
        { "itunes_ids", "" },
        { "next_episode_pub_date", "" },
        { "rsses", "" },
        { "show_latest_episodes", "" },
        { "spotify_ids", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/podcasts");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-listenapi-key", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/podcasts"

	payload := strings.NewReader("ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-listenapi-key", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/podcasts HTTP/1.1
X-Listenapi-Key: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 81

ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/podcasts")
  .setHeader("x-listenapi-key", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/podcasts"))
    .header("x-listenapi-key", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/podcasts")
  .post(body)
  .addHeader("x-listenapi-key", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/podcasts")
  .header("x-listenapi-key", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=")
  .asString();

const data = 'ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/podcasts');
xhr.setRequestHeader('x-listenapi-key', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('ids', '');
encodedParams.set('itunes_ids', '');
encodedParams.set('next_episode_pub_date', '');
encodedParams.set('rsses', '');
encodedParams.set('show_latest_episodes', '');
encodedParams.set('spotify_ids', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/podcasts',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/podcasts';
const options = {
  method: 'POST',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({
    ids: '',
    itunes_ids: '',
    next_episode_pub_date: '',
    rsses: '',
    show_latest_episodes: '',
    spotify_ids: ''
  })
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/podcasts',
  method: 'POST',
  headers: {
    'x-listenapi-key': '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    ids: '',
    itunes_ids: '',
    next_episode_pub_date: '',
    rsses: '',
    show_latest_episodes: '',
    spotify_ids: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=")
val request = Request.Builder()
  .url("{{baseUrl}}/podcasts")
  .post(body)
  .addHeader("x-listenapi-key", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/podcasts',
  headers: {
    'x-listenapi-key': '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

req.write(qs.stringify({
  ids: '',
  itunes_ids: '',
  next_episode_pub_date: '',
  rsses: '',
  show_latest_episodes: '',
  spotify_ids: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/podcasts',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {
    ids: '',
    itunes_ids: '',
    next_episode_pub_date: '',
    rsses: '',
    show_latest_episodes: '',
    spotify_ids: ''
  }
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/podcasts');

req.headers({
  'x-listenapi-key': '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  ids: '',
  itunes_ids: '',
  next_episode_pub_date: '',
  rsses: '',
  show_latest_episodes: '',
  spotify_ids: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('ids', '');
encodedParams.set('itunes_ids', '');
encodedParams.set('next_episode_pub_date', '');
encodedParams.set('rsses', '');
encodedParams.set('show_latest_episodes', '');
encodedParams.set('spotify_ids', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/podcasts',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('ids', '');
encodedParams.set('itunes_ids', '');
encodedParams.set('next_episode_pub_date', '');
encodedParams.set('rsses', '');
encodedParams.set('show_latest_episodes', '');
encodedParams.set('spotify_ids', '');

const url = '{{baseUrl}}/podcasts';
const options = {
  method: 'POST',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"ids=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&itunes_ids=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&next_episode_pub_date=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&rsses=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&show_latest_episodes=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&spotify_ids=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/podcasts" in
let headers = Header.add_list (Header.init ()) [
  ("x-listenapi-key", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=" in

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

 "{{baseUrl}}/podcasts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/podcasts', [
  'form_params' => [
    'ids' => '',
    'itunes_ids' => '',
    'next_episode_pub_date' => '',
    'rsses' => '',
    'show_latest_episodes' => '',
    'spotify_ids' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/podcasts');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-listenapi-key' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'ids' => '',
  'itunes_ids' => '',
  'next_episode_pub_date' => '',
  'rsses' => '',
  'show_latest_episodes' => '',
  'spotify_ids' => ''
]);

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

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

append(new http\QueryString([
  'ids' => '',
  'itunes_ids' => '',
  'next_episode_pub_date' => '',
  'rsses' => '',
  'show_latest_episodes' => '',
  'spotify_ids' => ''
]));

$request->setRequestUrl('{{baseUrl}}/podcasts');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-listenapi-key' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids='

$headers=@{}
$headers.Add("x-listenapi-key", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids='

import http.client

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

payload = "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids="

headers = {
    'x-listenapi-key': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/podcasts", payload, headers)

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

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

import requests

url = "{{baseUrl}}/podcasts"

payload = {
    "ids": "",
    "itunes_ids": "",
    "next_episode_pub_date": "",
    "rsses": "",
    "show_latest_episodes": "",
    "spotify_ids": ""
}
headers = {
    "x-listenapi-key": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

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

payload <- "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('x-listenapi-key' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/podcasts")

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

request = Net::HTTP::Post.new(url)
request["x-listenapi-key"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids="

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

require 'faraday'

data = {
  :ids => "",
  :itunes_ids => "",
  :next_episode_pub_date => "",
  :rsses => "",
  :show_latest_episodes => "",
  :spotify_ids => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/podcasts') do |req|
  req.headers['x-listenapi-key'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ids": "",
        "itunes_ids": "",
        "next_episode_pub_date": "",
        "rsses": "",
        "show_latest_episodes": "",
        "spotify_ids": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/podcasts \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'x-listenapi-key: ' \
  --data ids= \
  --data itunes_ids= \
  --data next_episode_pub_date= \
  --data rsses= \
  --data show_latest_episodes= \
  --data spotify_ids=

http --form POST {{baseUrl}}/podcasts \
  content-type:application/x-www-form-urlencoded \
  x-listenapi-key:'' \
  ids='' \
  itunes_ids='' \
  next_episode_pub_date='' \
  rsses='' \
  show_latest_episodes='' \
  spotify_ids=''

wget --quiet \
  --method POST \
  --header 'x-listenapi-key: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'ids=&itunes_ids=&next_episode_pub_date=&rsses=&show_latest_episodes=&spotify_ids=' \
  --output-document \
  - {{baseUrl}}/podcasts

import Foundation

let headers = [
  "x-listenapi-key": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "ids=".data(using: String.Encoding.utf8)!)
postData.append("&itunes_ids=".data(using: String.Encoding.utf8)!)
postData.append("&next_episode_pub_date=".data(using: String.Encoding.utf8)!)
postData.append("&rsses=".data(using: String.Encoding.utf8)!)
postData.append("&show_latest_episodes=".data(using: String.Encoding.utf8)!)
postData.append("&spotify_ids=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

GET Fetch a curated list of podcasts by id

{{baseUrl}}/curated_podcasts/:id

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/curated_podcasts/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/curated_podcasts/:id" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/curated_podcasts/:id"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/curated_podcasts/:id"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/curated_podcasts/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/curated_podcasts/:id"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/curated_podcasts/:id HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/curated_podcasts/:id")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/curated_podcasts/:id"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/curated_podcasts/:id")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/curated_podcasts/:id")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/curated_podcasts/:id');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/curated_podcasts/:id',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/curated_podcasts/:id';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/curated_podcasts/:id',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/curated_podcasts/:id")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/curated_podcasts/:id',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/curated_podcasts/:id',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/curated_podcasts/:id');

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/curated_podcasts/:id',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/curated_podcasts/:id';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/curated_podcasts/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/curated_podcasts/:id" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/curated_podcasts/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/curated_podcasts/:id', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/curated_podcasts/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/curated_podcasts/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/curated_podcasts/:id' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/curated_podcasts/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/curated_podcasts/:id"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/curated_podcasts/:id"

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/curated_podcasts/:id")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/curated_podcasts/:id') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/curated_podcasts/:id \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/curated_podcasts/:id \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/curated_podcasts/:id

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/curated_podcasts/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Fetch a list of best podcasts by genre

{{baseUrl}}/best_podcasts

HEADERS

X-ListenAPI-Key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/best_podcasts");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/best_podcasts" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/best_podcasts"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/best_podcasts");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/best_podcasts"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/best_podcasts HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/best_podcasts")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/best_podcasts"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/best_podcasts")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/best_podcasts")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/best_podcasts');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/best_podcasts',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/best_podcasts';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/best_podcasts',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/best_podcasts")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/best_podcasts',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/best_podcasts',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/best_podcasts',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/best_podcasts';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/best_podcasts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/best_podcasts" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/best_podcasts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/best_podcasts', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/best_podcasts');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/best_podcasts' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/best_podcasts' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/best_podcasts", headers=headers)

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

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

import requests

url = "{{baseUrl}}/best_podcasts"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/best_podcasts")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/best_podcasts') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/best_podcasts \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/best_podcasts \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/best_podcasts

import Foundation

let headers = ["x-listenapi-key": ""]

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

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

dataTask.resume()

GET Fetch a list of podcast genres

{{baseUrl}}/genres

HEADERS

X-ListenAPI-Key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/genres");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/genres" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/genres"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/genres");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/genres"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/genres HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/genres")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/genres"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/genres")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/genres")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/genres');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/genres',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/genres';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/genres',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/genres")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/genres',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/genres',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/genres',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/genres';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/genres"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/genres" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/genres",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/genres', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/genres');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/genres' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/genres' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/genres", headers=headers)

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

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

import requests

url = "{{baseUrl}}/genres"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/genres")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/genres') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/genres \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/genres \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/genres

import Foundation

let headers = ["x-listenapi-key": ""]

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

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

dataTask.resume()

GET Fetch a list of supported countries-regions for best podcasts

{{baseUrl}}/regions

HEADERS

X-ListenAPI-Key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/regions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/regions" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/regions"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/regions");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/regions"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/regions HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/regions")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/regions"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/regions")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/regions")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/regions');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/regions',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/regions';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/regions',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/regions")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/regions',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/regions',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/regions',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/regions';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/regions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/regions" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/regions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/regions', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/regions');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/regions' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/regions' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/regions", headers=headers)

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

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

import requests

url = "{{baseUrl}}/regions"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/regions")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/regions \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/regions \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/regions

import Foundation

let headers = ["x-listenapi-key": ""]

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

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

dataTask.resume()

GET Fetch a list of supported languages for podcasts

{{baseUrl}}/languages

HEADERS

X-ListenAPI-Key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/languages");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/languages" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/languages"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/languages");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/languages"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/languages HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/languages")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/languages"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/languages")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/languages")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/languages');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/languages',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/languages';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/languages',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/languages")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/languages',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/languages',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/languages',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/languages';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/languages"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/languages" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/languages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/languages', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/languages');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/languages' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/languages' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/languages", headers=headers)

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

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

import requests

url = "{{baseUrl}}/languages"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/languages")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/languages') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/languages \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/languages \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/languages

import Foundation

let headers = ["x-listenapi-key": ""]

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

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

dataTask.resume()

GET Fetch a random podcast episode

{{baseUrl}}/just_listen

HEADERS

X-ListenAPI-Key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/just_listen");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/just_listen" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/just_listen"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/just_listen");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/just_listen"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/just_listen HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/just_listen")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/just_listen"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/just_listen")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/just_listen")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/just_listen');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/just_listen',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/just_listen';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/just_listen',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/just_listen")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/just_listen',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/just_listen',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/just_listen',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/just_listen';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/just_listen"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/just_listen" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/just_listen",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/just_listen', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/just_listen');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/just_listen' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/just_listen' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/just_listen", headers=headers)

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

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

import requests

url = "{{baseUrl}}/just_listen"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/just_listen")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/just_listen') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/just_listen \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/just_listen \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/just_listen

import Foundation

let headers = ["x-listenapi-key": ""]

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

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

dataTask.resume()

GET Fetch curated lists of podcasts

{{baseUrl}}/curated_podcasts

HEADERS

X-ListenAPI-Key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/curated_podcasts");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/curated_podcasts" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/curated_podcasts"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/curated_podcasts");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/curated_podcasts"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/curated_podcasts HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/curated_podcasts")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/curated_podcasts"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/curated_podcasts")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/curated_podcasts")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/curated_podcasts');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/curated_podcasts',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/curated_podcasts';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/curated_podcasts',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/curated_podcasts")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/curated_podcasts',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/curated_podcasts',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/curated_podcasts',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/curated_podcasts';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/curated_podcasts"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/curated_podcasts" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/curated_podcasts",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/curated_podcasts', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/curated_podcasts');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/curated_podcasts' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/curated_podcasts' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/curated_podcasts", headers=headers)

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

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

import requests

url = "{{baseUrl}}/curated_podcasts"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/curated_podcasts")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/curated_podcasts') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/curated_podcasts \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/curated_podcasts \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/curated_podcasts

import Foundation

let headers = ["x-listenapi-key": ""]

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

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

dataTask.resume()

GET Fetch detailed meta data and episodes for a podcast by id

{{baseUrl}}/podcasts/:id

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/podcasts/:id" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/podcasts/:id"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/podcasts/:id"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/podcasts/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/podcasts/:id"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/podcasts/:id HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/podcasts/:id")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/podcasts/:id"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/podcasts/:id")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/podcasts/:id")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/podcasts/:id');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/podcasts/:id',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/podcasts/:id';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/podcasts/:id',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/podcasts/:id")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/podcasts/:id',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/podcasts/:id',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/podcasts/:id');

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/podcasts/:id',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/podcasts/:id';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/podcasts/:id" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/podcasts/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/podcasts/:id', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/podcasts/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts/:id' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/podcasts/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/podcasts/:id"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/podcasts/:id"

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/podcasts/:id")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/podcasts/:id') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/podcasts/:id \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/podcasts/:id \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/podcasts/:id

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Fetch detailed meta data for an episode by id

{{baseUrl}}/episodes/:id

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/episodes/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/episodes/:id" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/episodes/:id"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/episodes/:id"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/episodes/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/episodes/:id HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/episodes/:id")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/episodes/:id"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/episodes/:id")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/episodes/:id")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/episodes/:id');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:id',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/episodes/:id';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/episodes/:id',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/episodes/:id")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/episodes/:id',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:id',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:id',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/episodes/:id';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/episodes/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/episodes/:id" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/episodes/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/episodes/:id', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/episodes/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/episodes/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/episodes/:id' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/episodes/:id", headers=headers)

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

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

import requests

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

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/episodes/:id")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/episodes/:id') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/episodes/:id \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/episodes/:id \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/episodes/:id

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/episodes/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Fetch recommendations for a podcast

{{baseUrl}}/podcasts/:id/recommendations

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts/:id/recommendations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/podcasts/:id/recommendations" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/podcasts/:id/recommendations"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/podcasts/:id/recommendations"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/podcasts/:id/recommendations");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/podcasts/:id/recommendations"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/podcasts/:id/recommendations HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/podcasts/:id/recommendations")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/podcasts/:id/recommendations"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/podcasts/:id/recommendations")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/podcasts/:id/recommendations")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/podcasts/:id/recommendations');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/podcasts/:id/recommendations',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/podcasts/:id/recommendations';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/podcasts/:id/recommendations',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/podcasts/:id/recommendations")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/podcasts/:id/recommendations',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/podcasts/:id/recommendations',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/podcasts/:id/recommendations');

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/podcasts/:id/recommendations',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/podcasts/:id/recommendations';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts/:id/recommendations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/podcasts/:id/recommendations" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/podcasts/:id/recommendations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/podcasts/:id/recommendations', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/podcasts/:id/recommendations');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/podcasts/:id/recommendations');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts/:id/recommendations' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts/:id/recommendations' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/podcasts/:id/recommendations", headers=headers)

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

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

import requests

url = "{{baseUrl}}/podcasts/:id/recommendations"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/podcasts/:id/recommendations"

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/podcasts/:id/recommendations")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/podcasts/:id/recommendations') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/podcasts/:id/recommendations \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/podcasts/:id/recommendations \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/podcasts/:id/recommendations

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts/:id/recommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Fetch recommendations for an episode

{{baseUrl}}/episodes/:id/recommendations

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/episodes/:id/recommendations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/episodes/:id/recommendations" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/episodes/:id/recommendations"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/episodes/:id/recommendations"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/episodes/:id/recommendations");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/episodes/:id/recommendations"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/episodes/:id/recommendations HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/episodes/:id/recommendations")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/episodes/:id/recommendations"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/episodes/:id/recommendations")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/episodes/:id/recommendations")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/episodes/:id/recommendations');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:id/recommendations',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/episodes/:id/recommendations';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/episodes/:id/recommendations',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/episodes/:id/recommendations")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/episodes/:id/recommendations',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:id/recommendations',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/episodes/:id/recommendations',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/episodes/:id/recommendations';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/episodes/:id/recommendations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/episodes/:id/recommendations" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/episodes/:id/recommendations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/episodes/:id/recommendations', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/episodes/:id/recommendations');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/episodes/:id/recommendations' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/episodes/:id/recommendations' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/episodes/:id/recommendations", headers=headers)

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

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

import requests

url = "{{baseUrl}}/episodes/:id/recommendations"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/episodes/:id/recommendations"

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/episodes/:id/recommendations")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/episodes/:id/recommendations') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/episodes/:id/recommendations \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/episodes/:id/recommendations \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/episodes/:id/recommendations

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/episodes/:id/recommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Fetch audience demographics for a podcast

{{baseUrl}}/podcasts/:id/audience

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts/:id/audience");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/podcasts/:id/audience" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/podcasts/:id/audience"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/podcasts/:id/audience"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/podcasts/:id/audience");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/podcasts/:id/audience"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/podcasts/:id/audience HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/podcasts/:id/audience")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/podcasts/:id/audience"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/podcasts/:id/audience")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/podcasts/:id/audience")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/podcasts/:id/audience');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/podcasts/:id/audience',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/podcasts/:id/audience';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/podcasts/:id/audience',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/podcasts/:id/audience")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/podcasts/:id/audience',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/podcasts/:id/audience',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/podcasts/:id/audience');

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/podcasts/:id/audience',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/podcasts/:id/audience';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts/:id/audience"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/podcasts/:id/audience" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/podcasts/:id/audience",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/podcasts/:id/audience', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/podcasts/:id/audience');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/podcasts/:id/audience');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts/:id/audience' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts/:id/audience' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/podcasts/:id/audience", headers=headers)

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

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

import requests

url = "{{baseUrl}}/podcasts/:id/audience"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/podcasts/:id/audience"

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/podcasts/:id/audience")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/podcasts/:id/audience') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/podcasts/:id/audience \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/podcasts/:id/audience \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/podcasts/:id/audience

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts/:id/audience")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

GET Fetch a list of your playlists.

{{baseUrl}}/playlists

HEADERS

X-ListenAPI-Key

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/playlists");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/playlists" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/playlists"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/playlists");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/playlists"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/playlists HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/playlists")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/playlists"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/playlists")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/playlists")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/playlists');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/playlists',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/playlists';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/playlists',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/playlists")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/playlists',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/playlists',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/playlists',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/playlists';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/playlists"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/playlists" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/playlists",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/playlists', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/playlists');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/playlists' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/playlists' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/playlists", headers=headers)

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

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

import requests

url = "{{baseUrl}}/playlists"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/playlists")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/playlists') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/playlists \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/playlists \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/playlists

import Foundation

let headers = ["x-listenapi-key": ""]

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

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

dataTask.resume()

GET Fetch a playlist's info and items (i.e., episodes or podcasts).

{{baseUrl}}/playlists/:id

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/playlists/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/playlists/:id" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/playlists/:id"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/playlists/:id"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/playlists/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/playlists/:id"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/playlists/:id HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/playlists/:id")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/playlists/:id"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/playlists/:id")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/playlists/:id")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/playlists/:id');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/playlists/:id',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/playlists/:id';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/playlists/:id',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/playlists/:id")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/playlists/:id',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/playlists/:id',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/playlists/:id');

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/playlists/:id',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/playlists/:id';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/playlists/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/playlists/:id" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/playlists/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/playlists/:id', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/playlists/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/playlists/:id' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/playlists/:id' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/playlists/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/playlists/:id"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/playlists/:id"

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/playlists/:id")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/playlists/:id') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/playlists/:id \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/playlists/:id \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/playlists/:id

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/playlists/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

DELETE Request to delete a podcast

{{baseUrl}}/podcasts/:id

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/podcasts/:id" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/podcasts/:id"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/podcasts/:id"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/podcasts/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/podcasts/:id"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

DELETE /baseUrl/podcasts/:id HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/podcasts/:id")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/podcasts/:id"))
    .header("x-listenapi-key", "")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/podcasts/:id")
  .delete(null)
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/podcasts/:id")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/podcasts/:id');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/podcasts/:id',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/podcasts/:id';
const options = {method: 'DELETE', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/podcasts/:id',
  method: 'DELETE',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/podcasts/:id")
  .delete(null)
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/podcasts/:id',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/podcasts/:id',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/podcasts/:id');

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/podcasts/:id',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/podcasts/:id';
const options = {method: 'DELETE', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/podcasts/:id" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/podcasts/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/podcasts/:id', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/podcasts/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/podcasts/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts/:id' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts/:id' -Method DELETE -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("DELETE", "/baseUrl/podcasts/:id", headers=headers)

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

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

import requests

url = "{{baseUrl}}/podcasts/:id"

headers = {"x-listenapi-key": ""}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/podcasts/:id"

response <- VERB("DELETE", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/podcasts/:id")

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

request = Net::HTTP::Delete.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.delete('/baseUrl/podcasts/:id') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/podcasts/:id \
  --header 'x-listenapi-key: '

http DELETE {{baseUrl}}/podcasts/:id \
  x-listenapi-key:''

wget --quiet \
  --method DELETE \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/podcasts/:id

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

POST Submit a podcast to Listen Notes database

{{baseUrl}}/podcasts/submit

HEADERS

X-ListenAPI-Key

BODY formUrlEncoded

rss

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/podcasts/submit");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
headers = curl_slist_append(headers, "content-type: application/x-www-form-urlencoded");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "email=&rss=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/podcasts/submit" {:headers {:x-listenapi-key ""}
                                                            :form-params {:email ""
                                                                          :rss ""}})

require "http/client"

url = "{{baseUrl}}/podcasts/submit"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
  "content-type" => "application/x-www-form-urlencoded"
}
reqBody = "email=&rss="

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/podcasts/submit"),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
    Content = new FormUrlEncodedContent(new Dictionary
    {
        { "email", "" },
        { "rss", "" },
    }),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/podcasts/submit");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-listenapi-key", "");
request.AddHeader("content-type", "application/x-www-form-urlencoded");
request.AddParameter("application/x-www-form-urlencoded", "email=&rss=", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/podcasts/submit"

	payload := strings.NewReader("email=&rss=")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-listenapi-key", "")
	req.Header.Add("content-type", "application/x-www-form-urlencoded")

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

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

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

}

POST /baseUrl/podcasts/submit HTTP/1.1
X-Listenapi-Key: 
Content-Type: application/x-www-form-urlencoded
Host: example.com
Content-Length: 11

email=&rss=

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/podcasts/submit")
  .setHeader("x-listenapi-key", "")
  .setHeader("content-type", "application/x-www-form-urlencoded")
  .setBody("email=&rss=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/podcasts/submit"))
    .header("x-listenapi-key", "")
    .header("content-type", "application/x-www-form-urlencoded")
    .method("POST", HttpRequest.BodyPublishers.ofString("email=&rss="))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
RequestBody body = RequestBody.create(mediaType, "email=&rss=");
Request request = new Request.Builder()
  .url("{{baseUrl}}/podcasts/submit")
  .post(body)
  .addHeader("x-listenapi-key", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/podcasts/submit")
  .header("x-listenapi-key", "")
  .header("content-type", "application/x-www-form-urlencoded")
  .body("email=&rss=")
  .asString();

const data = 'email=&rss=';

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/podcasts/submit');
xhr.setRequestHeader('x-listenapi-key', '');
xhr.setRequestHeader('content-type', 'application/x-www-form-urlencoded');

xhr.send(data);

import axios from 'axios';

const encodedParams = new URLSearchParams();
encodedParams.set('email', '');
encodedParams.set('rss', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/podcasts/submit',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const url = '{{baseUrl}}/podcasts/submit';
const options = {
  method: 'POST',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  body: new URLSearchParams({email: '', rss: ''})
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/podcasts/submit',
  method: 'POST',
  headers: {
    'x-listenapi-key': '',
    'content-type': 'application/x-www-form-urlencoded'
  },
  data: {
    email: '',
    rss: ''
  }
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/x-www-form-urlencoded")
val body = RequestBody.create(mediaType, "email=&rss=")
val request = Request.Builder()
  .url("{{baseUrl}}/podcasts/submit")
  .post(body)
  .addHeader("x-listenapi-key", "")
  .addHeader("content-type", "application/x-www-form-urlencoded")
  .build()

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

const qs = require('querystring');
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/podcasts/submit',
  headers: {
    'x-listenapi-key': '',
    'content-type': 'application/x-www-form-urlencoded'
  }
};

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

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

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

req.write(qs.stringify({email: '', rss: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/podcasts/submit',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  form: {email: '', rss: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/podcasts/submit');

req.headers({
  'x-listenapi-key': '',
  'content-type': 'application/x-www-form-urlencoded'
});

req.form({
  email: '',
  rss: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;
const { URLSearchParams } = require('url');

const encodedParams = new URLSearchParams();
encodedParams.set('email', '');
encodedParams.set('rss', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/podcasts/submit',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  data: encodedParams,
};

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

const { URLSearchParams } = require('url');
const fetch = require('node-fetch');

const encodedParams = new URLSearchParams();
encodedParams.set('email', '');
encodedParams.set('rss', '');

const url = '{{baseUrl}}/podcasts/submit';
const options = {
  method: 'POST',
  headers: {'x-listenapi-key': '', 'content-type': 'application/x-www-form-urlencoded'},
  body: encodedParams
};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"",
                           @"content-type": @"application/x-www-form-urlencoded" };

NSMutableData *postData = [[NSMutableData alloc] initWithData:[@"email=" dataUsingEncoding:NSUTF8StringEncoding]];
[postData appendData:[@"&rss=" dataUsingEncoding:NSUTF8StringEncoding]];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/podcasts/submit"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/podcasts/submit" in
let headers = Header.add_list (Header.init ()) [
  ("x-listenapi-key", "");
  ("content-type", "application/x-www-form-urlencoded");
] in
let body = Cohttp_lwt_body.of_string "email=&rss=" in

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

 "{{baseUrl}}/podcasts/submit",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "email=&rss=",
  CURLOPT_HTTPHEADER => [
    "content-type: application/x-www-form-urlencoded",
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/podcasts/submit', [
  'form_params' => [
    'email' => '',
    'rss' => ''
  ],
  'headers' => [
    'content-type' => 'application/x-www-form-urlencoded',
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/podcasts/submit');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-listenapi-key' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

$request->setContentType('application/x-www-form-urlencoded');
$request->setPostFields([
  'email' => '',
  'rss' => ''
]);

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

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

append(new http\QueryString([
  'email' => '',
  'rss' => ''
]));

$request->setRequestUrl('{{baseUrl}}/podcasts/submit');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-listenapi-key' => '',
  'content-type' => 'application/x-www-form-urlencoded'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/podcasts/submit' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'email=&rss='

$headers=@{}
$headers.Add("x-listenapi-key", "")
$headers.Add("content-type", "application/x-www-form-urlencoded")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/podcasts/submit' -Method POST -Headers $headers -ContentType 'application/x-www-form-urlencoded' -Body 'email=&rss='

import http.client

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

payload = "email=&rss="

headers = {
    'x-listenapi-key': "",
    'content-type': "application/x-www-form-urlencoded"
}

conn.request("POST", "/baseUrl/podcasts/submit", payload, headers)

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

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

import requests

url = "{{baseUrl}}/podcasts/submit"

payload = {
    "email": "",
    "rss": ""
}
headers = {
    "x-listenapi-key": "",
    "content-type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/podcasts/submit"

payload <- "email=&rss="

encode <- "form"

response <- VERB("POST", url, body = payload, add_headers('x-listenapi-key' = ''), content_type("application/x-www-form-urlencoded"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/podcasts/submit")

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

request = Net::HTTP::Post.new(url)
request["x-listenapi-key"] = ''
request["content-type"] = 'application/x-www-form-urlencoded'
request.body = "email=&rss="

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

require 'faraday'

data = {
  :email => "",
  :rss => "",
}

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/x-www-form-urlencoded'}
)

response = conn.post('/baseUrl/podcasts/submit') do |req|
  req.headers['x-listenapi-key'] = ''
  req.body = URI.encode_www_form(data)
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "email": "",
        "rss": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());
    headers.insert("content-type", "application/x-www-form-urlencoded".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .form(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/podcasts/submit \
  --header 'content-type: application/x-www-form-urlencoded' \
  --header 'x-listenapi-key: ' \
  --data email= \
  --data rss=

http --form POST {{baseUrl}}/podcasts/submit \
  content-type:application/x-www-form-urlencoded \
  x-listenapi-key:'' \
  email='' \
  rss=''

wget --quiet \
  --method POST \
  --header 'x-listenapi-key: ' \
  --header 'content-type: application/x-www-form-urlencoded' \
  --body-data 'email=&rss=' \
  --output-document \
  - {{baseUrl}}/podcasts/submit

import Foundation

let headers = [
  "x-listenapi-key": "",
  "content-type": "application/x-www-form-urlencoded"
]

let postData = NSMutableData(data: "email=".data(using: String.Encoding.utf8)!)
postData.append("&rss=".data(using: String.Encoding.utf8)!)

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/podcasts/submit")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/related_searches" {:headers {:x-listenapi-key ""}
                                                            :query-params {:q ""}})

require "http/client"

url = "{{baseUrl}}/related_searches?q="
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/related_searches?q=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/related_searches?q="

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/related_searches?q= HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/related_searches?q=")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/related_searches?q="))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/related_searches?q=")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/related_searches?q=")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/related_searches?q=');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/related_searches',
  params: {q: ''},
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/related_searches?q=';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/related_searches?q=',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/related_searches?q=")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/related_searches?q=',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/related_searches',
  qs: {q: ''},
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/related_searches',
  params: {q: ''},
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/related_searches?q=';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/related_searches?q=" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/related_searches?q=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/related_searches?q=', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/related_searches?q=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/related_searches?q=' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/related_searches?q=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/related_searches"

querystring = {"q":""}

headers = {"x-listenapi-key": ""}

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

print(response.json())

library(httr)

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

queryString <- list(q = "")

response <- VERB("GET", url, query = queryString, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/related_searches?q=")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/related_searches') do |req|
  req.headers['x-listenapi-key'] = ''
  req.params['q'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/related_searches?q=' \
  --header 'x-listenapi-key: '

http GET '{{baseUrl}}/related_searches?q=' \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - '{{baseUrl}}/related_searches?q='

import Foundation

let headers = ["x-listenapi-key": ""]

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

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

dataTask.resume()

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/trending_searches");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/trending_searches" {:headers {:x-listenapi-key ""}})

require "http/client"

url = "{{baseUrl}}/trending_searches"
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

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

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

var client = new RestClient("{{baseUrl}}/trending_searches");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/trending_searches"

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

	req.Header.Add("x-listenapi-key", "")

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

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

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

}

GET /baseUrl/trending_searches HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/trending_searches")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/trending_searches"))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/trending_searches")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/trending_searches")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/trending_searches');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/trending_searches',
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/trending_searches';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/trending_searches',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/trending_searches")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/trending_searches',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/trending_searches',
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

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

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/trending_searches',
  headers: {'x-listenapi-key': ''}
};

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

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

const url = '{{baseUrl}}/trending_searches';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/trending_searches"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/trending_searches" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

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

 "{{baseUrl}}/trending_searches",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/trending_searches', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/trending_searches');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-listenapi-key' => ''
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/trending_searches' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/trending_searches' -Method GET -Headers $headers

import http.client

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

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/trending_searches", headers=headers)

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

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

import requests

url = "{{baseUrl}}/trending_searches"

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

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

response <- VERB("GET", url, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/trending_searches")

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

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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

require 'faraday'

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

response = conn.get('/baseUrl/trending_searches') do |req|
  req.headers['x-listenapi-key'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/trending_searches \
  --header 'x-listenapi-key: '

http GET {{baseUrl}}/trending_searches \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - {{baseUrl}}/trending_searches

import Foundation

let headers = ["x-listenapi-key": ""]

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

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

dataTask.resume()

GET Full-text search

{{baseUrl}}/search

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/search" {:headers {:x-listenapi-key ""}
                                                  :query-params {:q ""}})

require "http/client"

url = "{{baseUrl}}/search?q="
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

response = HTTP::Client.get url, headers: headers
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="),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
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=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/search?q="

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

	req.Header.Add("x-listenapi-key", "")

	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= HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/search?q=")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/search?q="))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/search?q=")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/search?q=")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/search?q=');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/search',
  params: {q: ''},
  headers: {'x-listenapi-key': ''}
};

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

const url = '{{baseUrl}}/search?q=';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/search?q=',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/search?q=")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/search?q=',
  headers: {
    'x-listenapi-key': ''
  }
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/search',
  qs: {q: ''},
  headers: {'x-listenapi-key': ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/search',
  params: {q: ''},
  headers: {'x-listenapi-key': ''}
};

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=';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/search?q="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/search?q=" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/search?q=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

$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=', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/search');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'q' => ''
]);

$request->setHeaders([
  'x-listenapi-key' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/search');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'q' => ''
]));

$request->setHeaders([
  'x-listenapi-key' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/search?q=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/search?q=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/search?q=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/search"

querystring = {"q":""}

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/search"

queryString <- list(q = "")

response <- VERB("GET", url, query = queryString, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/search?q=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

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.headers['x-listenapi-key'] = ''
  req.params['q'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/search";

    let querystring = [
        ("q", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/search?q=' \
  --header 'x-listenapi-key: '

http GET '{{baseUrl}}/search?q=' \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - '{{baseUrl}}/search?q='

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/search?q=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Spell check on a search term

{{baseUrl}}/spellcheck

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/spellcheck?q=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/spellcheck" {:headers {:x-listenapi-key ""}
                                                      :query-params {:q ""}})

require "http/client"

url = "{{baseUrl}}/spellcheck?q="
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/spellcheck?q="),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/spellcheck?q=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/spellcheck?q="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-listenapi-key", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/spellcheck?q= HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/spellcheck?q=")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/spellcheck?q="))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/spellcheck?q=")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/spellcheck?q=")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/spellcheck?q=');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/spellcheck',
  params: {q: ''},
  headers: {'x-listenapi-key': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/spellcheck?q=';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/spellcheck?q=',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/spellcheck?q=")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/spellcheck?q=',
  headers: {
    'x-listenapi-key': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/spellcheck',
  qs: {q: ''},
  headers: {'x-listenapi-key': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/spellcheck');

req.query({
  q: ''
});

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/spellcheck',
  params: {q: ''},
  headers: {'x-listenapi-key': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/spellcheck?q=';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/spellcheck?q="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/spellcheck?q=" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/spellcheck?q=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/spellcheck?q=', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/spellcheck');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'q' => ''
]);

$request->setHeaders([
  'x-listenapi-key' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/spellcheck');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'q' => ''
]));

$request->setHeaders([
  'x-listenapi-key' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/spellcheck?q=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/spellcheck?q=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/spellcheck?q=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/spellcheck"

querystring = {"q":""}

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/spellcheck"

queryString <- list(q = "")

response <- VERB("GET", url, query = queryString, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/spellcheck?q=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/spellcheck') do |req|
  req.headers['x-listenapi-key'] = ''
  req.params['q'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/spellcheck";

    let querystring = [
        ("q", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/spellcheck?q=' \
  --header 'x-listenapi-key: '

http GET '{{baseUrl}}/spellcheck?q=' \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - '{{baseUrl}}/spellcheck?q='

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/spellcheck?q=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Typeahead search

{{baseUrl}}/typeahead

HEADERS

X-ListenAPI-Key

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/typeahead?q=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-listenapi-key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/typeahead" {:headers {:x-listenapi-key ""}
                                                     :query-params {:q ""}})

require "http/client"

url = "{{baseUrl}}/typeahead?q="
headers = HTTP::Headers{
  "x-listenapi-key" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/typeahead?q="),
    Headers =
    {
        { "x-listenapi-key", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/typeahead?q=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-listenapi-key", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/typeahead?q="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-listenapi-key", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/typeahead?q= HTTP/1.1
X-Listenapi-Key: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/typeahead?q=")
  .setHeader("x-listenapi-key", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/typeahead?q="))
    .header("x-listenapi-key", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/typeahead?q=")
  .get()
  .addHeader("x-listenapi-key", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/typeahead?q=")
  .header("x-listenapi-key", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/typeahead?q=');
xhr.setRequestHeader('x-listenapi-key', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/typeahead',
  params: {q: ''},
  headers: {'x-listenapi-key': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/typeahead?q=';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/typeahead?q=',
  method: 'GET',
  headers: {
    'x-listenapi-key': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/typeahead?q=")
  .get()
  .addHeader("x-listenapi-key", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/typeahead?q=',
  headers: {
    'x-listenapi-key': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/typeahead',
  qs: {q: ''},
  headers: {'x-listenapi-key': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/typeahead');

req.query({
  q: ''
});

req.headers({
  'x-listenapi-key': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/typeahead',
  params: {q: ''},
  headers: {'x-listenapi-key': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/typeahead?q=';
const options = {method: 'GET', headers: {'x-listenapi-key': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-listenapi-key": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/typeahead?q="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/typeahead?q=" in
let headers = Header.add (Header.init ()) "x-listenapi-key" "" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/typeahead?q=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-listenapi-key: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/typeahead?q=', [
  'headers' => [
    'x-listenapi-key' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/typeahead');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'q' => ''
]);

$request->setHeaders([
  'x-listenapi-key' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/typeahead');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'q' => ''
]));

$request->setHeaders([
  'x-listenapi-key' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/typeahead?q=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-listenapi-key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/typeahead?q=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-listenapi-key': "" }

conn.request("GET", "/baseUrl/typeahead?q=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/typeahead"

querystring = {"q":""}

headers = {"x-listenapi-key": ""}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/typeahead"

queryString <- list(q = "")

response <- VERB("GET", url, query = queryString, add_headers('x-listenapi-key' = ''), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/typeahead?q=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-listenapi-key"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/typeahead') do |req|
  req.headers['x-listenapi-key'] = ''
  req.params['q'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/typeahead";

    let querystring = [
        ("q", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-listenapi-key", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/typeahead?q=' \
  --header 'x-listenapi-key: '

http GET '{{baseUrl}}/typeahead?q=' \
  x-listenapi-key:''

wget --quiet \
  --method GET \
  --header 'x-listenapi-key: ' \
  --output-document \
  - '{{baseUrl}}/typeahead?q='

import Foundation

let headers = ["x-listenapi-key": ""]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/typeahead?q=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()