POST create clip
{{baseUrl}}/api/v1/clips
HEADERS
Authorization
{{apiKey}}
BODY json
{
  "data": {
    "attributes": {
      "end_time": "",
      "media_id": "",
      "name": "",
      "start_time": ""
    }
  }
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/clips");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/clips" {:headers {:authorization "{{apiKey}}"}
                                                         :content-type :json
                                                         :form-params {:data {:attributes {:end_time ""
                                                                                           :media_id ""
                                                                                           :name ""
                                                                                           :start_time ""}}}})
require "http/client"

url = "{{baseUrl}}/api/v1/clips"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"

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}}/api/v1/clips"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/clips");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/clips"

	payload := strings.NewReader("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")

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

	req.Header.Add("authorization", "{{apiKey}}")
	req.Header.Add("content-type", "application/json")

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

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

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

}
POST /baseUrl/api/v1/clips HTTP/1.1
Authorization: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "data": {
    "attributes": {
      "end_time": "",
      "media_id": "",
      "name": "",
      "start_time": ""
    }
  }
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/clips")
  .setHeader("authorization", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/clips"))
    .header("authorization", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/clips")
  .post(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/clips")
  .header("authorization", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")
  .asString();
const data = JSON.stringify({
  data: {
    attributes: {
      end_time: '',
      media_id: '',
      name: '',
      start_time: ''
    }
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/clips');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/clips',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {end_time: '', media_id: '', name: '', start_time: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/clips';
const options = {
  method: 'POST',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"end_time":"","media_id":"","name":"","start_time":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/clips',
  method: 'POST',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "data": {\n    "attributes": {\n      "end_time": "",\n      "media_id": "",\n      "name": "",\n      "start_time": ""\n    }\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/clips")
  .post(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/clips',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({data: {attributes: {end_time: '', media_id: '', name: '', start_time: ''}}}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/clips',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: {data: {attributes: {end_time: '', media_id: '', name: '', start_time: ''}}},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/clips');

req.headers({
  authorization: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  data: {
    attributes: {
      end_time: '',
      media_id: '',
      name: '',
      start_time: ''
    }
  }
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/clips',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {end_time: '', media_id: '', name: '', start_time: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/clips';
const options = {
  method: 'POST',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"end_time":"","media_id":"","name":"","start_time":""}}}'
};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"data": @{ @"attributes": @{ @"end_time": @"", @"media_id": @"", @"name": @"", @"start_time": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/clips"]
                                                       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}}/api/v1/clips" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/clips",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'data' => [
        'attributes' => [
                'end_time' => '',
                'media_id' => '',
                'name' => '',
                'start_time' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/api/v1/clips', [
  'body' => '{
  "data": {
    "attributes": {
      "end_time": "",
      "media_id": "",
      "name": "",
      "start_time": ""
    }
  }
}',
  'headers' => [
    'authorization' => '{{apiKey}}',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/clips');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'data' => [
    'attributes' => [
        'end_time' => '',
        'media_id' => '',
        'name' => '',
        'start_time' => ''
    ]
  ]
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'data' => [
    'attributes' => [
        'end_time' => '',
        'media_id' => '',
        'name' => '',
        'start_time' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/clips');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/clips' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "end_time": "",
      "media_id": "",
      "name": "",
      "start_time": ""
    }
  }
}'
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/clips' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "end_time": "",
      "media_id": "",
      "name": "",
      "start_time": ""
    }
  }
}'
import http.client

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

payload = "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"

headers = {
    'authorization': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/v1/clips", payload, headers)

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

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

url = "{{baseUrl}}/api/v1/clips"

payload = { "data": { "attributes": {
            "end_time": "",
            "media_id": "",
            "name": "",
            "start_time": ""
        } } }
headers = {
    "authorization": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/clips"

payload <- "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('authorization' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/clips")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/api/v1/clips') do |req|
  req.headers['authorization'] = '{{apiKey}}'
  req.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"media_id\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({"data": json!({"attributes": json!({
                "end_time": "",
                "media_id": "",
                "name": "",
                "start_time": ""
            })})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/clips \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --data '{
  "data": {
    "attributes": {
      "end_time": "",
      "media_id": "",
      "name": "",
      "start_time": ""
    }
  }
}'
echo '{
  "data": {
    "attributes": {
      "end_time": "",
      "media_id": "",
      "name": "",
      "start_time": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/api/v1/clips \
  authorization:'{{apiKey}}' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "data": {\n    "attributes": {\n      "end_time": "",\n      "media_id": "",\n      "name": "",\n      "start_time": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/clips
import Foundation

let headers = [
  "authorization": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["data": ["attributes": [
      "end_time": "",
      "media_id": "",
      "name": "",
      "start_time": ""
    ]]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/clips")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": {
    "attributes": {
      "created_at": "2022-08-15T18:34:09.431Z",
      "end_char": 0,
      "end_time": 2,
      "external_id": null,
      "is_processing": null,
      "media_file_content_type": null,
      "media_file_duration": null,
      "media_file_height": null,
      "media_file_preview_image_url": null,
      "media_file_url": null,
      "media_file_width": null,
      "name": "Example New Clip",
      "processing_started_at": "2022-08-17T21:08:29.615Z",
      "rank": null,
      "start_char": 0,
      "start_time": 1,
      "text": null
    },
    "id": "a5d24ac9-86bc-46a9-b188-6dfff81c838c",
    "relationships": {
      "media": {
        "data": {
          "id": "dde75ca2-77ad-4dfa-b4f0-61ccff99a296",
          "type": "medias"
        }
      }
    },
    "type": "clips"
  },
  "links": {
    "self": "http://api.contentgroove.com/api/v1/clips"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "code": "exceeded_quota_count",
      "detail": "You have exceeded the monthly quota for number of clips. Please visit the Settings / Quota Usage page to see your usage and manage your account.",
      "source": {
        "pointer": ""
      },
      "status": "422",
      "title": "Unprocessable Entity"
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
POST create media
{{baseUrl}}/api/v1/medias
HEADERS
Authorization
{{apiKey}}
BODY json
{
  "data": {
    "attributes": {
      "description": "",
      "name": "",
      "source_url": "",
      "upload_id": ""
    }
  }
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/medias");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/medias" {:headers {:authorization "{{apiKey}}"}
                                                          :content-type :json
                                                          :form-params {:data {:attributes {:description ""
                                                                                            :name ""
                                                                                            :source_url ""
                                                                                            :upload_id ""}}}})
require "http/client"

url = "{{baseUrl}}/api/v1/medias"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}"

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}}/api/v1/medias"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/medias");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/medias"

	payload := strings.NewReader("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}")

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

	req.Header.Add("authorization", "{{apiKey}}")
	req.Header.Add("content-type", "application/json")

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

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

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

}
POST /baseUrl/api/v1/medias HTTP/1.1
Authorization: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 134

{
  "data": {
    "attributes": {
      "description": "",
      "name": "",
      "source_url": "",
      "upload_id": ""
    }
  }
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/medias")
  .setHeader("authorization", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/medias"))
    .header("authorization", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/medias")
  .post(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/medias")
  .header("authorization", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}")
  .asString();
const data = JSON.stringify({
  data: {
    attributes: {
      description: '',
      name: '',
      source_url: '',
      upload_id: ''
    }
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/medias');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/medias',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {description: '', name: '', source_url: '', upload_id: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/medias';
const options = {
  method: 'POST',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"description":"","name":"","source_url":"","upload_id":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/medias',
  method: 'POST',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "data": {\n    "attributes": {\n      "description": "",\n      "name": "",\n      "source_url": "",\n      "upload_id": ""\n    }\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/medias")
  .post(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/medias',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({data: {attributes: {description: '', name: '', source_url: '', upload_id: ''}}}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/medias',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: {data: {attributes: {description: '', name: '', source_url: '', upload_id: ''}}},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/medias');

req.headers({
  authorization: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  data: {
    attributes: {
      description: '',
      name: '',
      source_url: '',
      upload_id: ''
    }
  }
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/medias',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {description: '', name: '', source_url: '', upload_id: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/medias';
const options = {
  method: 'POST',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"description":"","name":"","source_url":"","upload_id":""}}}'
};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"data": @{ @"attributes": @{ @"description": @"", @"name": @"", @"source_url": @"", @"upload_id": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/medias"]
                                                       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}}/api/v1/medias" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/medias",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'data' => [
        'attributes' => [
                'description' => '',
                'name' => '',
                'source_url' => '',
                'upload_id' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/api/v1/medias', [
  'body' => '{
  "data": {
    "attributes": {
      "description": "",
      "name": "",
      "source_url": "",
      "upload_id": ""
    }
  }
}',
  'headers' => [
    'authorization' => '{{apiKey}}',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/medias');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'data' => [
    'attributes' => [
        'description' => '',
        'name' => '',
        'source_url' => '',
        'upload_id' => ''
    ]
  ]
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'data' => [
    'attributes' => [
        'description' => '',
        'name' => '',
        'source_url' => '',
        'upload_id' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/medias');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/medias' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "description": "",
      "name": "",
      "source_url": "",
      "upload_id": ""
    }
  }
}'
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/medias' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "description": "",
      "name": "",
      "source_url": "",
      "upload_id": ""
    }
  }
}'
import http.client

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

payload = "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}"

headers = {
    'authorization': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/v1/medias", payload, headers)

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

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

url = "{{baseUrl}}/api/v1/medias"

payload = { "data": { "attributes": {
            "description": "",
            "name": "",
            "source_url": "",
            "upload_id": ""
        } } }
headers = {
    "authorization": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/medias"

payload <- "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('authorization' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/medias")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/api/v1/medias') do |req|
  req.headers['authorization'] = '{{apiKey}}'
  req.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\",\n      \"source_url\": \"\",\n      \"upload_id\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({"data": json!({"attributes": json!({
                "description": "",
                "name": "",
                "source_url": "",
                "upload_id": ""
            })})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/medias \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --data '{
  "data": {
    "attributes": {
      "description": "",
      "name": "",
      "source_url": "",
      "upload_id": ""
    }
  }
}'
echo '{
  "data": {
    "attributes": {
      "description": "",
      "name": "",
      "source_url": "",
      "upload_id": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/api/v1/medias \
  authorization:'{{apiKey}}' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "data": {\n    "attributes": {\n      "description": "",\n      "name": "",\n      "source_url": "",\n      "upload_id": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/medias
import Foundation

let headers = [
  "authorization": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["data": ["attributes": [
      "description": "",
      "name": "",
      "source_url": "",
      "upload_id": ""
    ]]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/medias")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": {
    "attributes": {
      "created_at": "2022-08-15T18:34:13.256Z",
      "description": null,
      "external_id": null,
      "has_fetch_error": false,
      "is_processing": null,
      "name": "",
      "original_created_at": null,
      "processing_started_at": "2022-08-17T21:08:34.662Z",
      "source_created_at": null,
      "source_file_content_type": null,
      "source_file_duration": null,
      "source_file_height": null,
      "source_file_preview_image_url": null,
      "source_file_width": null,
      "source_url": "https://archive.org/download/SF143/SF143_512kb.mp4"
    },
    "id": "654599f2-d989-492b-ba66-19dc722e983c",
    "relationships": {
      "clips": {
        "data": []
      },
      "transcription": {
        "data": null
      }
    },
    "type": "medias"
  },
  "links": {
    "self": "http://api.contentgroove.com/api/v1/medias"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "code": "exceeded_quota_count",
      "detail": "You have exceeded the monthly quota for number of medias. Please visit the Settings / Quota Usage page to see your usage and manage your account.",
      "source": {
        "pointer": ""
      },
      "status": "422",
      "title": "Unprocessable Entity"
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
POST create webhook subscription
{{baseUrl}}/api/v1/webhook_subscriptions
HEADERS
Authorization
{{apiKey}}
BODY json
{
  "data": {
    "attributes": {
      "subscribed_events": [],
      "url": ""
    }
  }
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/webhook_subscriptions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/v1/webhook_subscriptions" {:headers {:authorization "{{apiKey}}"}
                                                                         :content-type :json
                                                                         :form-params {:data {:attributes {:subscribed_events []
                                                                                                           :url ""}}}})
require "http/client"

url = "{{baseUrl}}/api/v1/webhook_subscriptions"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}"

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}}/api/v1/webhook_subscriptions"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/webhook_subscriptions");
var request = new RestRequest("", Method.Post);
request.AddHeader("authorization", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/webhook_subscriptions"

	payload := strings.NewReader("{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}")

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

	req.Header.Add("authorization", "{{apiKey}}")
	req.Header.Add("content-type", "application/json")

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

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

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

}
POST /baseUrl/api/v1/webhook_subscriptions HTTP/1.1
Authorization: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "data": {
    "attributes": {
      "subscribed_events": [],
      "url": ""
    }
  }
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/v1/webhook_subscriptions")
  .setHeader("authorization", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/webhook_subscriptions"))
    .header("authorization", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/webhook_subscriptions")
  .post(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.post("{{baseUrl}}/api/v1/webhook_subscriptions")
  .header("authorization", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}")
  .asString();
const data = JSON.stringify({
  data: {
    attributes: {
      subscribed_events: [],
      url: ''
    }
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/api/v1/webhook_subscriptions');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {subscribed_events: [], url: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/webhook_subscriptions';
const options = {
  method: 'POST',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"subscribed_events":[],"url":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/webhook_subscriptions',
  method: 'POST',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "data": {\n    "attributes": {\n      "subscribed_events": [],\n      "url": ""\n    }\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/webhook_subscriptions")
  .post(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/webhook_subscriptions',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({data: {attributes: {subscribed_events: [], url: ''}}}));
req.end();
const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: {data: {attributes: {subscribed_events: [], url: ''}}},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/v1/webhook_subscriptions');

req.headers({
  authorization: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  data: {
    attributes: {
      subscribed_events: [],
      url: ''
    }
  }
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {subscribed_events: [], url: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/webhook_subscriptions';
const options = {
  method: 'POST',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"subscribed_events":[],"url":""}}}'
};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"data": @{ @"attributes": @{ @"subscribed_events": @[  ], @"url": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/webhook_subscriptions"]
                                                       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}}/api/v1/webhook_subscriptions" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/webhook_subscriptions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'data' => [
        'attributes' => [
                'subscribed_events' => [
                                
                ],
                'url' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('POST', '{{baseUrl}}/api/v1/webhook_subscriptions', [
  'body' => '{
  "data": {
    "attributes": {
      "subscribed_events": [],
      "url": ""
    }
  }
}',
  'headers' => [
    'authorization' => '{{apiKey}}',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/webhook_subscriptions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'data' => [
    'attributes' => [
        'subscribed_events' => [
                
        ],
        'url' => ''
    ]
  ]
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'data' => [
    'attributes' => [
        'subscribed_events' => [
                
        ],
        'url' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/webhook_subscriptions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/webhook_subscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "subscribed_events": [],
      "url": ""
    }
  }
}'
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/webhook_subscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "subscribed_events": [],
      "url": ""
    }
  }
}'
import http.client

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

payload = "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}"

headers = {
    'authorization': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/v1/webhook_subscriptions", payload, headers)

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

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

url = "{{baseUrl}}/api/v1/webhook_subscriptions"

payload = { "data": { "attributes": {
            "subscribed_events": [],
            "url": ""
        } } }
headers = {
    "authorization": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/webhook_subscriptions"

payload <- "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('authorization' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/webhook_subscriptions")

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

request = Net::HTTP::Post.new(url)
request["authorization"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.post('/baseUrl/api/v1/webhook_subscriptions') do |req|
  req.headers['authorization'] = '{{apiKey}}'
  req.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"subscribed_events\": [],\n      \"url\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body
use serde_json::json;
use reqwest;

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

    let payload = json!({"data": json!({"attributes": json!({
                "subscribed_events": (),
                "url": ""
            })})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/v1/webhook_subscriptions \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --data '{
  "data": {
    "attributes": {
      "subscribed_events": [],
      "url": ""
    }
  }
}'
echo '{
  "data": {
    "attributes": {
      "subscribed_events": [],
      "url": ""
    }
  }
}' |  \
  http POST {{baseUrl}}/api/v1/webhook_subscriptions \
  authorization:'{{apiKey}}' \
  content-type:application/json
wget --quiet \
  --method POST \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "data": {\n    "attributes": {\n      "subscribed_events": [],\n      "url": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/webhook_subscriptions
import Foundation

let headers = [
  "authorization": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["data": ["attributes": [
      "subscribed_events": [],
      "url": ""
    ]]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/webhook_subscriptions")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": {
    "attributes": {
      "active": true,
      "created_at": "2022-10-13T19:04:07.154Z",
      "subscribed_events": [
        "*"
      ],
      "updated_at": "2022-10-13T19:04:07.154Z",
      "url": "https://example.com/contentgroove_webhooks/12345"
    },
    "id": "d812aaec-55e8-47b8-a9b6-3905082a53fb",
    "relationships": {
      "user": {
        "data": {
          "id": "e9adb7a5-6169-4041-8d23-d1fdb6294198",
          "type": "users"
        }
      },
      "webhook_events": {
        "data": []
      }
    },
    "type": "webhook_subscriptions"
  },
  "links": {
    "self": "http://api.contentgroove.com/api/v1/webhook_subscriptions"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
DELETE delete clip
{{baseUrl}}/api/v1/clips/:id
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/clips/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/v1/clips/:id" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/clips/:id"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/clips/:id"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/clips/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/clips/:id"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
DELETE /baseUrl/api/v1/clips/:id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/clips/:id")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/clips/:id"))
    .header("authorization", "{{apiKey}}")
    .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}}/api/v1/clips/:id")
  .delete(null)
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/clips/:id")
  .header("authorization", "{{apiKey}}")
  .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}}/api/v1/clips/:id');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v1/clips/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/clips/:id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/clips/:id',
  method: 'DELETE',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/clips/:id")
  .delete(null)
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/clips/:id',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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}}/api/v1/clips/:id',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v1/clips/:id');

req.headers({
  authorization: '{{apiKey}}'
});

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}}/api/v1/clips/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/clips/:id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/clips/: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}}/api/v1/clips/:id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/clips/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/api/v1/clips/:id', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/clips/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/clips/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/clips/:id' -Method DELETE -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/clips/:id' -Method DELETE -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/api/v1/clips/:id", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/clips/:id"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/clips/:id"

response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/clips/:id")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.delete('/baseUrl/api/v1/clips/:id') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/clips/:id \
  --header 'authorization: {{apiKey}}'
http DELETE {{baseUrl}}/api/v1/clips/:id \
  authorization:'{{apiKey}}'
wget --quiet \
  --method DELETE \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/clips/:id
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/clips/: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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": null,
      "source": null,
      "status": "404",
      "title": "Not Found"
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
DELETE delete media
{{baseUrl}}/api/v1/medias/:id
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/medias/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/v1/medias/:id" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/medias/:id"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/medias/:id"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/medias/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/medias/:id"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
DELETE /baseUrl/api/v1/medias/:id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/medias/:id")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/medias/:id"))
    .header("authorization", "{{apiKey}}")
    .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}}/api/v1/medias/:id")
  .delete(null)
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/medias/:id")
  .header("authorization", "{{apiKey}}")
  .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}}/api/v1/medias/:id');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v1/medias/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/medias/:id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/medias/:id',
  method: 'DELETE',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/medias/:id")
  .delete(null)
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/medias/:id',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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}}/api/v1/medias/:id',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v1/medias/:id');

req.headers({
  authorization: '{{apiKey}}'
});

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}}/api/v1/medias/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/medias/:id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/medias/: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}}/api/v1/medias/:id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/medias/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/api/v1/medias/:id', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/medias/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/medias/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/medias/:id' -Method DELETE -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/medias/:id' -Method DELETE -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/api/v1/medias/:id", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/medias/:id"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/medias/:id"

response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/medias/:id")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.delete('/baseUrl/api/v1/medias/:id') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/medias/:id \
  --header 'authorization: {{apiKey}}'
http DELETE {{baseUrl}}/api/v1/medias/:id \
  authorization:'{{apiKey}}'
wget --quiet \
  --method DELETE \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/medias/:id
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/medias/: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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": null,
      "source": null,
      "status": "404",
      "title": "Not Found"
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
DELETE delete webhook subscription
{{baseUrl}}/api/v1/webhook_subscriptions/:id
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/webhook_subscriptions/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/v1/webhook_subscriptions/:id" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/webhook_subscriptions/:id"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/webhook_subscriptions/:id"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/webhook_subscriptions/:id");
var request = new RestRequest("", Method.Delete);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/webhook_subscriptions/:id"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
DELETE /baseUrl/api/v1/webhook_subscriptions/:id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/v1/webhook_subscriptions/:id")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/webhook_subscriptions/:id"))
    .header("authorization", "{{apiKey}}")
    .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}}/api/v1/webhook_subscriptions/:id")
  .delete(null)
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.delete("{{baseUrl}}/api/v1/webhook_subscriptions/:id")
  .header("authorization", "{{apiKey}}")
  .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}}/api/v1/webhook_subscriptions/:id');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/webhook_subscriptions/:id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/webhook_subscriptions/:id',
  method: 'DELETE',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/webhook_subscriptions/:id")
  .delete(null)
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/webhook_subscriptions/:id',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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}}/api/v1/webhook_subscriptions/:id',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/v1/webhook_subscriptions/:id');

req.headers({
  authorization: '{{apiKey}}'
});

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}}/api/v1/webhook_subscriptions/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/webhook_subscriptions/:id';
const options = {method: 'DELETE', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/webhook_subscriptions/: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}}/api/v1/webhook_subscriptions/:id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/webhook_subscriptions/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('DELETE', '{{baseUrl}}/api/v1/webhook_subscriptions/:id', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/webhook_subscriptions/:id');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/webhook_subscriptions/:id');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/webhook_subscriptions/:id' -Method DELETE -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/webhook_subscriptions/:id' -Method DELETE -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/api/v1/webhook_subscriptions/:id", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/webhook_subscriptions/:id"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/webhook_subscriptions/:id"

response <- VERB("DELETE", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/webhook_subscriptions/:id")

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

request = Net::HTTP::Delete.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.delete('/baseUrl/api/v1/webhook_subscriptions/:id') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use std::str::FromStr;
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/webhook_subscriptions/:id \
  --header 'authorization: {{apiKey}}'
http DELETE {{baseUrl}}/api/v1/webhook_subscriptions/:id \
  authorization:'{{apiKey}}'
wget --quiet \
  --method DELETE \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/webhook_subscriptions/:id
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/webhook_subscriptions/: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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": null,
      "source": null,
      "status": "404",
      "title": "Not Found"
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
GET list clips
{{baseUrl}}/api/v1/clips
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/clips");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/clips" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/clips"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/clips"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/clips");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/clips"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
GET /baseUrl/api/v1/clips HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/clips")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/clips"))
    .header("authorization", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/clips")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/clips")
  .header("authorization", "{{apiKey}}")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/clips');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/clips',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/clips';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/clips',
  method: 'GET',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/clips")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/clips',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/clips',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/clips');

req.headers({
  authorization: '{{apiKey}}'
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/clips',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/clips';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/clips"]
                                                       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}}/api/v1/clips" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/clips",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/api/v1/clips', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/clips');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/clips');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/clips' -Method GET -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/clips' -Method GET -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/clips", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/clips"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/clips"

response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/clips")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/api/v1/clips') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/clips \
  --header 'authorization: {{apiKey}}'
http GET {{baseUrl}}/api/v1/clips \
  authorization:'{{apiKey}}'
wget --quiet \
  --method GET \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/clips
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/clips")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": [
    {
      "attributes": {
        "created_at": "2022-08-15T18:34:08.398Z",
        "end_char": 0,
        "end_time": 2,
        "external_id": "150",
        "is_processing": true,
        "media_file_content_type": null,
        "media_file_duration": null,
        "media_file_height": null,
        "media_file_preview_image_url": null,
        "media_file_url": null,
        "media_file_width": null,
        "name": "Example Clip",
        "processing_started_at": "2022-08-15T18:34:08.391Z",
        "rank": null,
        "start_char": 0,
        "start_time": 1,
        "text": null
      },
      "id": "32caa472-6a12-4a77-974a-52d1175502ab",
      "relationships": {
        "media": {
          "data": {
            "id": "dde75ca2-77ad-4dfa-b4f0-61ccff99a296",
            "type": "medias"
          }
        }
      },
      "type": "clips"
    }
  ],
  "links": {
    "current": "http://api.contentgroove.com/api/v1/clips?page[number]=1",
    "self": "http://api.contentgroove.com/api/v1/clips"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
GET list medias
{{baseUrl}}/api/v1/medias
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/medias");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/medias" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/medias"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/medias"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/medias");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/medias"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
GET /baseUrl/api/v1/medias HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/medias")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/medias"))
    .header("authorization", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/medias")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/medias")
  .header("authorization", "{{apiKey}}")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/medias');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/medias',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/medias';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/medias',
  method: 'GET',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/medias")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/medias',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/medias',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/medias');

req.headers({
  authorization: '{{apiKey}}'
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/medias',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/medias';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/medias"]
                                                       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}}/api/v1/medias" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/medias",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/api/v1/medias', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/medias');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/medias');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/medias' -Method GET -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/medias' -Method GET -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/medias", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/medias"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/medias"

response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/medias")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/api/v1/medias') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/medias \
  --header 'authorization: {{apiKey}}'
http GET {{baseUrl}}/api/v1/medias \
  authorization:'{{apiKey}}'
wget --quiet \
  --method GET \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/medias
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/medias")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": [
    {
      "attributes": {
        "created_at": "2022-08-17T02:13:58.431Z",
        "description": "Enos was the second chimpanzee launched into space by NASA. He was the first and only chimpanzee, and third hominid after cosmonauts Yuri Gagarin and Gherman Titov, to achieve Earth orbit. Enos's flight occurred on November 29, 1961. https://en.wikipedia.org/wiki/Enos_(chimpanzee)",
        "external_id": "468",
        "has_fetch_error": false,
        "is_processing": true,
        "name": "Chimp Into Space",
        "original_created_at": "2022-08-17T02:13:58.431Z",
        "processing_started_at": "2022-08-17T02:13:58.425Z",
        "source_created_at": null,
        "source_file_content_type": null,
        "source_file_duration": null,
        "source_file_height": null,
        "source_file_preview_image_url": null,
        "source_file_width": null,
        "source_url": "https://archive.org/download/SF143/SF143_512kb.mp4"
      },
      "id": "f98fae60-8086-41d5-8966-36698bf13de0",
      "relationships": {
        "clips": {
          "data": []
        }
      },
      "type": "medias"
    }
  ],
  "links": {
    "current": "http://api.contentgroove.com/api/v1/medias?page[number]=1",
    "self": "http://api.contentgroove.com/api/v1/medias"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
GET list webhook subscriptions
{{baseUrl}}/api/v1/webhook_subscriptions
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/webhook_subscriptions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/webhook_subscriptions" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/webhook_subscriptions"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/webhook_subscriptions"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/webhook_subscriptions");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/webhook_subscriptions"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
GET /baseUrl/api/v1/webhook_subscriptions HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/webhook_subscriptions")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/webhook_subscriptions"))
    .header("authorization", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/webhook_subscriptions")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/webhook_subscriptions")
  .header("authorization", "{{apiKey}}")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/webhook_subscriptions');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/webhook_subscriptions';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/webhook_subscriptions',
  method: 'GET',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/webhook_subscriptions")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/webhook_subscriptions',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/webhook_subscriptions');

req.headers({
  authorization: '{{apiKey}}'
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/webhook_subscriptions';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/webhook_subscriptions"]
                                                       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}}/api/v1/webhook_subscriptions" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/webhook_subscriptions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/api/v1/webhook_subscriptions', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/webhook_subscriptions');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/webhook_subscriptions');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/webhook_subscriptions' -Method GET -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/webhook_subscriptions' -Method GET -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/webhook_subscriptions", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/webhook_subscriptions"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/webhook_subscriptions"

response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/webhook_subscriptions")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/api/v1/webhook_subscriptions') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/webhook_subscriptions \
  --header 'authorization: {{apiKey}}'
http GET {{baseUrl}}/api/v1/webhook_subscriptions \
  authorization:'{{apiKey}}'
wget --quiet \
  --method GET \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/webhook_subscriptions
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/webhook_subscriptions")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": [
    {
      "attributes": {
        "active": true,
        "created_at": "2022-10-13T19:04:05.111Z",
        "subscribed_events": [
          "*"
        ],
        "updated_at": "2022-10-13T19:04:05.111Z",
        "url": "https://webhook.site/cd4ca31b-6d7d-414a-a3e5-a3a3ca42b25e"
      },
      "id": "d07aedb6-53fc-4141-b10c-083896e54ce2",
      "relationships": {
        "user": {
          "data": {
            "id": "aea66137-8ee1-4bab-bf5a-5d8a5bb4a7f9",
            "type": "users"
          }
        },
        "webhook_events": {
          "data": []
        }
      },
      "type": "webhook_subscriptions"
    }
  ],
  "links": {
    "current": "http://api.contentgroove.com/api/v1/webhook_subscriptions?page[number]=1",
    "self": "http://api.contentgroove.com/api/v1/webhook_subscriptions"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
GET prepare presigned upload url
{{baseUrl}}/api/v1/direct_uploads
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/direct_uploads");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/direct_uploads" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/direct_uploads"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/direct_uploads"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/direct_uploads");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/direct_uploads"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
GET /baseUrl/api/v1/direct_uploads HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/direct_uploads")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/direct_uploads"))
    .header("authorization", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/direct_uploads")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/direct_uploads")
  .header("authorization", "{{apiKey}}")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/direct_uploads');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/direct_uploads',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/direct_uploads';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/direct_uploads',
  method: 'GET',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/direct_uploads")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/direct_uploads',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/direct_uploads',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/v1/direct_uploads');

req.headers({
  authorization: '{{apiKey}}'
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/direct_uploads',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/direct_uploads';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/direct_uploads"]
                                                       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}}/api/v1/direct_uploads" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/direct_uploads",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/api/v1/direct_uploads', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/direct_uploads');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/direct_uploads');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/direct_uploads' -Method GET -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/direct_uploads' -Method GET -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/direct_uploads", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/direct_uploads"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/direct_uploads"

response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/direct_uploads")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/api/v1/direct_uploads') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/direct_uploads \
  --header 'authorization: {{apiKey}}'
http GET {{baseUrl}}/api/v1/direct_uploads \
  authorization:'{{apiKey}}'
wget --quiet \
  --method GET \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/direct_uploads
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/direct_uploads")! 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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": {
    "attributes": {
      "upload_id": "eyJfcmFpbHMiOnsibWVzc2FnZSI6IkJBaEpJaWszTVdWbFlXSTBNaTFqTWpsaUxUUm1NVFF0WVRBMVl5MWpOelprWkRnd1l6TTVZamNHT2daRlZBPT0iLCJleHAiOm51bGwsInB1ciI6ImJsb2JfaWQifX0=--0bc2a83b08eb0217bc7f0497302496329cf69ede",
      "upload_url": "(example URL for documentation only) https://file-uploads.contentgroove.com/vmf93z4328ioirtd6f5yb2nwbnq4d0ps?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIAZ44FA4RJICA5SPPQ%2F20220919%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20220919T165555Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host-content-type&X-Amz-Signature=df840423555070b29264382599459f1497ba2bd5e10e6a6dd41a29ebe239a8e0ecf"
    },
    "id": "71eeab42-c29b-4f14-a05c-c76dd80c39b7",
    "type": "direct_upload_blobs"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
GET show clip
{{baseUrl}}/api/v1/clips/:id
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/clips/:id" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/clips/:id"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/clips/:id"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/clips/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/clips/:id"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
GET /baseUrl/api/v1/clips/:id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/clips/:id")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/clips/:id"))
    .header("authorization", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/clips/:id")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/clips/:id")
  .header("authorization", "{{apiKey}}")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/clips/:id');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/clips/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/clips/:id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/clips/:id',
  method: 'GET',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/clips/:id")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/clips/:id',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/clips/:id',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

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

req.headers({
  authorization: '{{apiKey}}'
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/clips/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/clips/:id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/clips/: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}}/api/v1/clips/:id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/clips/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/api/v1/clips/:id', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/clips/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/clips/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/clips/:id' -Method GET -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/clips/:id' -Method GET -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/clips/:id", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/clips/:id"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/clips/:id"

response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/clips/:id")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/api/v1/clips/:id') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/clips/:id \
  --header 'authorization: {{apiKey}}'
http GET {{baseUrl}}/api/v1/clips/:id \
  authorization:'{{apiKey}}'
wget --quiet \
  --method GET \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/clips/:id
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/clips/: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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": {
    "attributes": {
      "created_at": "2022-08-15T18:34:08.398Z",
      "end_char": 0,
      "end_time": 2,
      "external_id": "155",
      "is_processing": true,
      "media_file_content_type": null,
      "media_file_duration": null,
      "media_file_height": null,
      "media_file_preview_image_url": null,
      "media_file_url": null,
      "media_file_width": null,
      "name": "Example Clip",
      "processing_started_at": "2022-08-15T18:34:08.391Z",
      "rank": null,
      "start_char": 0,
      "start_time": 1,
      "text": null
    },
    "id": "32caa472-6a12-4a77-974a-52d1175502ab",
    "relationships": {
      "media": {
        "data": {
          "id": "dde75ca2-77ad-4dfa-b4f0-61ccff99a296",
          "type": "medias"
        }
      }
    },
    "type": "clips"
  },
  "links": {
    "self": "http://api.contentgroove.com/api/v1/clips/32caa472-6a12-4a77-974a-52d1175502ab"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": null,
      "source": null,
      "status": "404",
      "title": "Not Found"
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
GET show media
{{baseUrl}}/api/v1/medias/:id
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/medias/:id" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/medias/:id"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/medias/:id"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/medias/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/medias/:id"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
GET /baseUrl/api/v1/medias/:id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/medias/:id")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/medias/:id"))
    .header("authorization", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/medias/:id")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/medias/:id")
  .header("authorization", "{{apiKey}}")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/medias/:id');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/medias/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/medias/:id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/medias/:id',
  method: 'GET',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/medias/:id")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/medias/:id',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/medias/:id',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

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

req.headers({
  authorization: '{{apiKey}}'
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/medias/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/medias/:id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/medias/: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}}/api/v1/medias/:id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/medias/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/api/v1/medias/:id', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/medias/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/medias/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/medias/:id' -Method GET -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/medias/:id' -Method GET -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/medias/:id", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/medias/:id"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/medias/:id"

response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/medias/:id")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/api/v1/medias/:id') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/medias/:id \
  --header 'authorization: {{apiKey}}'
http GET {{baseUrl}}/api/v1/medias/:id \
  authorization:'{{apiKey}}'
wget --quiet \
  --method GET \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/medias/:id
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/medias/: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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": {
    "attributes": {
      "created_at": "2022-08-17T02:13:58.431Z",
      "description": "Enos was the second chimpanzee launched into space by NASA. He was the first and only chimpanzee, and third hominid after cosmonauts Yuri Gagarin and Gherman Titov, to achieve Earth orbit. Enos's flight occurred on November 29, 1961. https://en.wikipedia.org/wiki/Enos_(chimpanzee)",
      "external_id": "474",
      "has_fetch_error": false,
      "is_processing": true,
      "name": "Chimp Into Space",
      "original_created_at": "2022-08-17T02:13:58.431Z",
      "processing_started_at": "2022-08-17T02:13:58.425Z",
      "source_created_at": null,
      "source_file_content_type": null,
      "source_file_duration": null,
      "source_file_height": null,
      "source_file_preview_image_url": null,
      "source_file_width": null,
      "source_url": "https://archive.org/download/SF143/SF143_512kb.mp4"
    },
    "id": "f98fae60-8086-41d5-8966-36698bf13de0",
    "relationships": {
      "clips": {
        "data": []
      },
      "transcription": {
        "data": null
      }
    },
    "type": "medias"
  },
  "links": {
    "self": "http://api.contentgroove.com/api/v1/medias/f98fae60-8086-41d5-8966-36698bf13de0"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": null,
      "source": null,
      "status": "404",
      "title": "Not Found"
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
GET show webhook subscription
{{baseUrl}}/api/v1/webhook_subscriptions/:id
HEADERS
Authorization
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/v1/webhook_subscriptions/:id" {:headers {:authorization "{{apiKey}}"}})
require "http/client"

url = "{{baseUrl}}/api/v1/webhook_subscriptions/:id"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
}

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}}/api/v1/webhook_subscriptions/:id"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/webhook_subscriptions/:id");
var request = new RestRequest("", Method.Get);
request.AddHeader("authorization", "{{apiKey}}");
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/webhook_subscriptions/:id"

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

	req.Header.Add("authorization", "{{apiKey}}")

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

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

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

}
GET /baseUrl/api/v1/webhook_subscriptions/:id HTTP/1.1
Authorization: {{apiKey}}
Host: example.com


AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/v1/webhook_subscriptions/:id")
  .setHeader("authorization", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/webhook_subscriptions/:id"))
    .header("authorization", "{{apiKey}}")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/webhook_subscriptions/:id")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.get("{{baseUrl}}/api/v1/webhook_subscriptions/:id")
  .header("authorization", "{{apiKey}}")
  .asString();
const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/api/v1/webhook_subscriptions/:id');
xhr.setRequestHeader('authorization', '{{apiKey}}');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/webhook_subscriptions/:id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/webhook_subscriptions/:id',
  method: 'GET',
  headers: {
    authorization: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/webhook_subscriptions/:id")
  .get()
  .addHeader("authorization", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/webhook_subscriptions/:id',
  headers: {
    authorization: '{{apiKey}}'
  }
};

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

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

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

req.end();
const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions/:id',
  headers: {authorization: '{{apiKey}}'}
};

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

  console.log(body);
});
const unirest = require('unirest');

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

req.headers({
  authorization: '{{apiKey}}'
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/v1/webhook_subscriptions/:id',
  headers: {authorization: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/webhook_subscriptions/:id';
const options = {method: 'GET', headers: {authorization: '{{apiKey}}'}};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/webhook_subscriptions/: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}}/api/v1/webhook_subscriptions/:id" in
let headers = Header.add (Header.init ()) "authorization" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/webhook_subscriptions/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('GET', '{{baseUrl}}/api/v1/webhook_subscriptions/:id', [
  'headers' => [
    'authorization' => '{{apiKey}}',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/webhook_subscriptions/:id');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
setRequestUrl('{{baseUrl}}/api/v1/webhook_subscriptions/:id');
$request->setRequestMethod('GET');
$request->setHeaders([
  'authorization' => '{{apiKey}}'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/webhook_subscriptions/:id' -Method GET -Headers $headers
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/webhook_subscriptions/:id' -Method GET -Headers $headers
import http.client

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

headers = { 'authorization': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/v1/webhook_subscriptions/:id", headers=headers)

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

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

url = "{{baseUrl}}/api/v1/webhook_subscriptions/:id"

headers = {"authorization": "{{apiKey}}"}

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

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/webhook_subscriptions/:id"

response <- VERB("GET", url, add_headers('authorization' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/webhook_subscriptions/:id")

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

request = Net::HTTP::Get.new(url)
request["authorization"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.get('/baseUrl/api/v1/webhook_subscriptions/:id') do |req|
  req.headers['authorization'] = '{{apiKey}}'
end

puts response.status
puts response.body
use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".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}}/api/v1/webhook_subscriptions/:id \
  --header 'authorization: {{apiKey}}'
http GET {{baseUrl}}/api/v1/webhook_subscriptions/:id \
  authorization:'{{apiKey}}'
wget --quiet \
  --method GET \
  --header 'authorization: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/v1/webhook_subscriptions/:id
import Foundation

let headers = ["authorization": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/webhook_subscriptions/: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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": {
    "attributes": {
      "active": true,
      "created_at": "2022-10-13T19:04:07.663Z",
      "subscribed_events": [
        "*"
      ],
      "updated_at": "2022-10-13T19:04:07.663Z",
      "url": "https://webhook.site/cd4ca31b-6d7d-414a-a3e5-a3a3ca42b25e"
    },
    "id": "481f57a0-ecdf-42ec-9837-bc551eb6909b",
    "relationships": {
      "user": {
        "data": {
          "id": "639597af-9230-4205-a539-b5c7177b514c",
          "type": "users"
        }
      },
      "webhook_events": {
        "data": []
      }
    },
    "type": "webhook_subscriptions"
  },
  "links": {
    "self": "http://api.contentgroove.com/api/v1/webhook_subscriptions/481f57a0-ecdf-42ec-9837-bc551eb6909b"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": null,
      "source": null,
      "status": "404",
      "title": "Not Found"
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
PUT update clip
{{baseUrl}}/api/v1/clips/:id
HEADERS
Authorization
{{apiKey}}
BODY json
{
  "data": {
    "attributes": {
      "end_time": "",
      "name": "",
      "start_time": ""
    }
  }
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/clips/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/v1/clips/:id" {:headers {:authorization "{{apiKey}}"}
                                                            :content-type :json
                                                            :form-params {:data {:attributes {:end_time ""
                                                                                              :name ""
                                                                                              :start_time ""}}}})
require "http/client"

url = "{{baseUrl}}/api/v1/clips/:id"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v1/clips/:id"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/clips/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/clips/:id"

	payload := strings.NewReader("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")

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

	req.Header.Add("authorization", "{{apiKey}}")
	req.Header.Add("content-type", "application/json")

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

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

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

}
PUT /baseUrl/api/v1/clips/:id HTTP/1.1
Authorization: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 108

{
  "data": {
    "attributes": {
      "end_time": "",
      "name": "",
      "start_time": ""
    }
  }
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/clips/:id")
  .setHeader("authorization", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/clips/:id"))
    .header("authorization", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/clips/:id")
  .put(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/clips/:id")
  .header("authorization", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")
  .asString();
const data = JSON.stringify({
  data: {
    attributes: {
      end_time: '',
      name: '',
      start_time: ''
    }
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/v1/clips/:id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/clips/:id',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {end_time: '', name: '', start_time: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/clips/:id';
const options = {
  method: 'PUT',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"end_time":"","name":"","start_time":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/clips/:id',
  method: 'PUT',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "data": {\n    "attributes": {\n      "end_time": "",\n      "name": "",\n      "start_time": ""\n    }\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/clips/:id")
  .put(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/clips/:id',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({data: {attributes: {end_time: '', name: '', start_time: ''}}}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/clips/:id',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: {data: {attributes: {end_time: '', name: '', start_time: ''}}},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v1/clips/:id');

req.headers({
  authorization: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  data: {
    attributes: {
      end_time: '',
      name: '',
      start_time: ''
    }
  }
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/clips/:id',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {end_time: '', name: '', start_time: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/clips/:id';
const options = {
  method: 'PUT',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"end_time":"","name":"","start_time":""}}}'
};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"data": @{ @"attributes": @{ @"end_time": @"", @"name": @"", @"start_time": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/clips/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/api/v1/clips/:id" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/clips/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'data' => [
        'attributes' => [
                'end_time' => '',
                'name' => '',
                'start_time' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/api/v1/clips/:id', [
  'body' => '{
  "data": {
    "attributes": {
      "end_time": "",
      "name": "",
      "start_time": ""
    }
  }
}',
  'headers' => [
    'authorization' => '{{apiKey}}',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/clips/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'data' => [
    'attributes' => [
        'end_time' => '',
        'name' => '',
        'start_time' => ''
    ]
  ]
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'data' => [
    'attributes' => [
        'end_time' => '',
        'name' => '',
        'start_time' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/clips/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/clips/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "end_time": "",
      "name": "",
      "start_time": ""
    }
  }
}'
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/clips/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "end_time": "",
      "name": "",
      "start_time": ""
    }
  }
}'
import http.client

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

payload = "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"

headers = {
    'authorization': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/api/v1/clips/:id", payload, headers)

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

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

url = "{{baseUrl}}/api/v1/clips/:id"

payload = { "data": { "attributes": {
            "end_time": "",
            "name": "",
            "start_time": ""
        } } }
headers = {
    "authorization": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/clips/:id"

payload <- "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('authorization' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/clips/:id")

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

request = Net::HTTP::Put.new(url)
request["authorization"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.put('/baseUrl/api/v1/clips/:id') do |req|
  req.headers['authorization'] = '{{apiKey}}'
  req.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"end_time\": \"\",\n      \"name\": \"\",\n      \"start_time\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({"data": json!({"attributes": json!({
                "end_time": "",
                "name": "",
                "start_time": ""
            })})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/api/v1/clips/:id \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --data '{
  "data": {
    "attributes": {
      "end_time": "",
      "name": "",
      "start_time": ""
    }
  }
}'
echo '{
  "data": {
    "attributes": {
      "end_time": "",
      "name": "",
      "start_time": ""
    }
  }
}' |  \
  http PUT {{baseUrl}}/api/v1/clips/:id \
  authorization:'{{apiKey}}' \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "data": {\n    "attributes": {\n      "end_time": "",\n      "name": "",\n      "start_time": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/clips/:id
import Foundation

let headers = [
  "authorization": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["data": ["attributes": [
      "end_time": "",
      "name": "",
      "start_time": ""
    ]]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/clips/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": {
    "attributes": {
      "created_at": "2022-08-15T18:34:08.398Z",
      "end_char": 0,
      "end_time": 2,
      "external_id": "158",
      "is_processing": true,
      "media_file_content_type": null,
      "media_file_duration": null,
      "media_file_height": null,
      "media_file_preview_image_url": null,
      "media_file_url": null,
      "media_file_width": null,
      "name": "Example Clip",
      "processing_started_at": "2022-08-15T18:34:08.391Z",
      "rank": null,
      "start_char": 0,
      "start_time": 1,
      "text": null
    },
    "id": "32caa472-6a12-4a77-974a-52d1175502ab",
    "relationships": {
      "media": {
        "data": {
          "id": "dde75ca2-77ad-4dfa-b4f0-61ccff99a296",
          "type": "medias"
        }
      }
    },
    "type": "clips"
  },
  "links": {
    "self": "http://api.contentgroove.com/api/v1/clips/32caa472-6a12-4a77-974a-52d1175502ab"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}
PUT update media
{{baseUrl}}/api/v1/medias/:id
HEADERS
Authorization
{{apiKey}}
BODY json
{
  "data": {
    "attributes": {
      "description": "",
      "name": ""
    }
  }
}
Examples
REQUEST
CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/v1/medias/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "authorization: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);
(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/v1/medias/:id" {:headers {:authorization "{{apiKey}}"}
                                                             :content-type :json
                                                             :form-params {:data {:attributes {:description ""
                                                                                               :name ""}}}})
require "http/client"

url = "{{baseUrl}}/api/v1/medias/:id"
headers = HTTP::Headers{
  "authorization" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body
using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/v1/medias/:id"),
    Headers =
    {
        { "authorization", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}
var client = new RestClient("{{baseUrl}}/api/v1/medias/:id");
var request = new RestRequest("", Method.Put);
request.AddHeader("authorization", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);
package main

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

func main() {

	url := "{{baseUrl}}/api/v1/medias/:id"

	payload := strings.NewReader("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}")

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

	req.Header.Add("authorization", "{{apiKey}}")
	req.Header.Add("content-type", "application/json")

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

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

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

}
PUT /baseUrl/api/v1/medias/:id HTTP/1.1
Authorization: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "data": {
    "attributes": {
      "description": "",
      "name": ""
    }
  }
}
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/v1/medias/:id")
  .setHeader("authorization", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/v1/medias/:id"))
    .header("authorization", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/v1/medias/:id")
  .put(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();
HttpResponse response = Unirest.put("{{baseUrl}}/api/v1/medias/:id")
  .header("authorization", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}")
  .asString();
const data = JSON.stringify({
  data: {
    attributes: {
      description: '',
      name: ''
    }
  }
});

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

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

xhr.open('PUT', '{{baseUrl}}/api/v1/medias/:id');
xhr.setRequestHeader('authorization', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);
import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/medias/:id',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {description: '', name: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const url = '{{baseUrl}}/api/v1/medias/:id';
const options = {
  method: 'PUT',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"description":"","name":""}}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/v1/medias/:id',
  method: 'PUT',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "data": {\n    "attributes": {\n      "description": "",\n      "name": ""\n    }\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/v1/medias/:id")
  .put(body)
  .addHeader("authorization", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()
const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/v1/medias/:id',
  headers: {
    authorization: '{{apiKey}}',
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({data: {attributes: {description: '', name: ''}}}));
req.end();
const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/medias/:id',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: {data: {attributes: {description: '', name: ''}}},
  json: true
};

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

  console.log(body);
});
const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/v1/medias/:id');

req.headers({
  authorization: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  data: {
    attributes: {
      description: '',
      name: ''
    }
  }
});

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

  console.log(res.body);
});
const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/v1/medias/:id',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  data: {data: {attributes: {description: '', name: ''}}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}
const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/v1/medias/:id';
const options = {
  method: 'PUT',
  headers: {authorization: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"data":{"attributes":{"description":"","name":""}}}'
};

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

NSDictionary *headers = @{ @"authorization": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"data": @{ @"attributes": @{ @"description": @"", @"name": @"" } } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/v1/medias/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[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}}/api/v1/medias/:id" in
let headers = Header.add_list (Header.init ()) [
  ("authorization", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)
 "{{baseUrl}}/api/v1/medias/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'data' => [
        'attributes' => [
                'description' => '',
                'name' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "authorization: {{apiKey}}",
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
request('PUT', '{{baseUrl}}/api/v1/medias/:id', [
  'body' => '{
  "data": {
    "attributes": {
      "description": "",
      "name": ""
    }
  }
}',
  'headers' => [
    'authorization' => '{{apiKey}}',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();
setUrl('{{baseUrl}}/api/v1/medias/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'data' => [
    'attributes' => [
        'description' => '',
        'name' => ''
    ]
  ]
]));

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

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}
append(json_encode([
  'data' => [
    'attributes' => [
        'description' => '',
        'name' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/v1/medias/:id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'authorization' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/v1/medias/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "description": "",
      "name": ""
    }
  }
}'
$headers=@{}
$headers.Add("authorization", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/v1/medias/:id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "data": {
    "attributes": {
      "description": "",
      "name": ""
    }
  }
}'
import http.client

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

payload = "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}"

headers = {
    'authorization': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/api/v1/medias/:id", payload, headers)

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

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

url = "{{baseUrl}}/api/v1/medias/:id"

payload = { "data": { "attributes": {
            "description": "",
            "name": ""
        } } }
headers = {
    "authorization": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())
library(httr)

url <- "{{baseUrl}}/api/v1/medias/:id"

payload <- "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('authorization' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")
require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/v1/medias/:id")

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

request = Net::HTTP::Put.new(url)
request["authorization"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}"

response = http.request(request)
puts response.read_body
require 'faraday'

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

response = conn.put('/baseUrl/api/v1/medias/:id') do |req|
  req.headers['authorization'] = '{{apiKey}}'
  req.body = "{\n  \"data\": {\n    \"attributes\": {\n      \"description\": \"\",\n      \"name\": \"\"\n    }\n  }\n}"
end

puts response.status
puts response.body
use std::str::FromStr;
use serde_json::json;
use reqwest;

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

    let payload = json!({"data": json!({"attributes": json!({
                "description": "",
                "name": ""
            })})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("authorization", "{{apiKey}}".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/api/v1/medias/:id \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --data '{
  "data": {
    "attributes": {
      "description": "",
      "name": ""
    }
  }
}'
echo '{
  "data": {
    "attributes": {
      "description": "",
      "name": ""
    }
  }
}' |  \
  http PUT {{baseUrl}}/api/v1/medias/:id \
  authorization:'{{apiKey}}' \
  content-type:application/json
wget --quiet \
  --method PUT \
  --header 'authorization: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "data": {\n    "attributes": {\n      "description": "",\n      "name": ""\n    }\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/v1/medias/:id
import Foundation

let headers = [
  "authorization": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["data": ["attributes": [
      "description": "",
      "name": ""
    ]]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/v1/medias/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "data": {
    "attributes": {
      "created_at": "2022-08-17T02:13:58.431Z",
      "description": "testdescription",
      "external_id": "477",
      "has_fetch_error": false,
      "is_processing": true,
      "name": "Chimp Into Space",
      "original_created_at": "2022-08-17T02:13:58.431Z",
      "processing_started_at": "2022-08-17T02:13:58.425Z",
      "source_created_at": null,
      "source_file_content_type": null,
      "source_file_duration": null,
      "source_file_height": null,
      "source_file_preview_image_url": null,
      "source_file_width": null,
      "source_url": "https://archive.org/download/SF143/SF143_512kb.mp4"
    },
    "id": "f98fae60-8086-41d5-8966-36698bf13de0",
    "relationships": {
      "clips": {
        "data": []
      },
      "transcription": {
        "data": null
      }
    },
    "type": "medias"
  },
  "links": {
    "self": "http://api.contentgroove.com/api/v1/medias/f98fae60-8086-41d5-8966-36698bf13de0"
  }
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "message": "You need to sign in or sign up before continuing."
    }
  ]
}
RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
  "errors": [
    {
      "detail": "You have exceeded the maximum number of requests in the current window. Please try again later.",
      "status": "429",
      "title": "Too Many Requests"
    }
  ]
}