They Said So Quotes API

POST Add a new quote to your private collection. Same as 'PUT' but added since some clients don't handle PUT well.

{{baseUrl}}/quote

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quote

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote?quote=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/quote" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                  :query-params {:quote ""}})

require "http/client"

url = "{{baseUrl}}/quote?quote="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/quote?quote="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote?quote=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote?quote="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

POST /baseUrl/quote?quote= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote?quote=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote?quote="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote?quote=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/quote?quote=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/quote?quote=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote',
  params: {quote: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote?quote=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/quote?quote=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote?quote=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote?quote=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote',
  qs: {quote: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote',
  params: {quote: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote?quote=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote?quote=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote?quote=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/quote?quote=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote?quote=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote?quote=' -Method POST -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/quote?quote=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote"

querystring = {"quote":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

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

queryString <- list(quote = "")

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote?quote=")

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

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.post('/baseUrl/quote') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['quote'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/quote?quote=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/quote?quote=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote?quote='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "content": {
    "quote": {
      "id": "0tztT1wYHRzdTf7jIccAzweF"
    }
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

PUT Add a new quote to your private collection.

{{baseUrl}}/quote

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quote

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote?quote=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/quote" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                 :query-params {:quote ""}})

require "http/client"

url = "{{baseUrl}}/quote?quote="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/quote?quote="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote?quote=");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote?quote="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

PUT /baseUrl/quote?quote= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/quote?quote=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote?quote="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote?quote=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/quote?quote=")
  .header("x-theysaidso-api-secret", "{{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('PUT', '{{baseUrl}}/quote?quote=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/quote',
  params: {quote: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote?quote=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{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}}/quote?quote=',
  method: 'PUT',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote?quote=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote?quote=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/quote',
  qs: {quote: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/quote');

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

req.headers({
  'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/quote',
  params: {quote: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote?quote=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote?quote=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote?quote=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/quote?quote=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote');
$request->setMethod(HTTP_METH_PUT);

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote?quote=' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote?quote=' -Method PUT -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("PUT", "/baseUrl/quote?quote=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote"

querystring = {"quote":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.put(url, headers=headers, params=querystring)

print(response.json())

library(httr)

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

queryString <- list(quote = "")

response <- VERB("PUT", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote?quote=")

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

request = Net::HTTP::Put.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.put('/baseUrl/quote') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['quote'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/quote?quote=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http PUT '{{baseUrl}}/quote?quote=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote?quote='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "content": {
    "quote": {
      "id": "0tztT1wYHRzdTf7jIccAzweF"
    }
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

POST Add a tag to a given Quote.

{{baseUrl}}/quote/tags/add

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

tags

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/tags/add?id=&tags=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/quote/tags/add" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                           :query-params {:id ""
                                                                          :tags ""}})

require "http/client"

url = "{{baseUrl}}/quote/tags/add?id=&tags="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/quote/tags/add?id=&tags="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/tags/add?id=&tags=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/tags/add?id=&tags="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

POST /baseUrl/quote/tags/add?id=&tags= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/tags/add?id=&tags=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/tags/add?id=&tags="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/tags/add?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/quote/tags/add?id=&tags=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/quote/tags/add?id=&tags=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/tags/add',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/tags/add?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/quote/tags/add?id=&tags=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/tags/add?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/tags/add?id=&tags=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/tags/add',
  qs: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/quote/tags/add');

req.query({
  id: '',
  tags: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/tags/add',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/tags/add?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/tags/add?id=&tags="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/tags/add?id=&tags=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote/tags/add?id=&tags=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/quote/tags/add?id=&tags=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/tags/add');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'id' => '',
  'tags' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/tags/add');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'id' => '',
  'tags' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/tags/add?id=&tags=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/tags/add?id=&tags=' -Method POST -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/quote/tags/add?id=&tags=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote/tags/add"

querystring = {"id":"","tags":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/tags/add"

queryString <- list(
  id = "",
  tags = ""
)

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/tags/add?id=&tags=")

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

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.post('/baseUrl/quote/tags/add') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
  req.params['tags'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("id", ""),
        ("tags", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/quote/tags/add?id=&tags=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/quote/tags/add?id=&tags=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/tags/add?id=&tags='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/tags/add?id=&tags=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "contents": {
    "message": "Tags added"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

DELETE Delete a quote. The user needs to be the owner of the quote to be able to delete it.

{{baseUrl}}/quote

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/quote" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                    :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/quote?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote?id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote?id="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

DELETE /baseUrl/quote?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/quote?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote?id="))
    .header("x-theysaidso-api-secret", "{{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}}/quote?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/quote?id=")
  .header("x-theysaidso-api-secret", "{{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}}/quote?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/quote',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{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}}/quote?id=',
  method: 'DELETE',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/quote');

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

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

 "{{baseUrl}}/quote?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/quote?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote');
$request->setMethod(HTTP_METH_DELETE);

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote?id=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote?id=' -Method DELETE -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/quote?id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

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

queryString <- list(id = "")

response <- VERB("DELETE", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote?id=")

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

request = Net::HTTP::Delete.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.delete('/baseUrl/quote') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/quote?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http DELETE '{{baseUrl}}/quote?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote?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/xml

RESPONSE BODY xml

{}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

GET Get the list of quotes in your private collection.

{{baseUrl}}/quote/list

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/quote/list" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/list"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/list"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/list");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/list"

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/quote/list HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/list")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/list"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/list")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/quote/list")
  .header("x-theysaidso-api-secret", "{{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}}/quote/list');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/list',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/list';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/list',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/list")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/list',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/list',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/list');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/list',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/list';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

 "{{baseUrl}}/quote/list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/quote/list', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/list' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

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

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

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

import requests

url = "{{baseUrl}}/quote/list"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/list"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/list")

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/quote/list') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/list \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/list \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/list

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/list")! 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

{
    "success": {
        "total": "263",
        "range": {
            "start": 0,
            "end": 5
        }
    },
    "contents": {
        "quotes": [
            {
                "quote": "I think you should defend to the death their right to march, and then go down and meet them with baseball bats.",
                "length": "111",
                "author": "Woody Allen",
                "tags": [],
                "id": "GkeLUydBfiAH0Tcs2w_gwAeF"
            },
            {
                "quote": "We have come to dedicate a portion of that field, as a final resting place for those who here gave their lives that that nation might live. It is altogether fitting and proper that we should do this. ... The world will little note nor long remember what we say here, but it can never forget what they did here.",
                "length": "310",
                "author": "Abraham Lincoln",
                "tags": [],
                "id": "u6fD9eRFA2NFMHuEoeujaAeF"
            },
            {
                "quote": "Eighty percent of success is showing up.",
                "length": "40",
                "author": "Woody Allen",
                "tags": [
                    "success",
                    "tso-top-100"
                ],
                "id": "nLvp0vLfofW06PILxmERHgeF"
            },
            {
                "quote": "Great ambition is the passion of a great character.  Those endowed with it may perform very good or very bad acts.  All depends on the principals which direct them.",
                "length": "164",
                "author": "Napoleon Bonaparte",
                "tags": [
                    "ambition",
                    "inspire",
                    "passion"
                ],
                "id": "X8juAoTtvxSEdgA0sGbYeQeF"
            },
            {
                "quote": "I have had dreams, and I have had nightmares. I overcame the nightmares because of my dreams.",
                "length": "93",
                "author": "Dr. Jonas Salk",
                "tags": [
                    "dream",
                    "nightmare"
                ],
                "id": "m_6Fj8QcXlVsQiiW7SAMLAeF"
            }
        ]
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

POST Remove a tag from a given quote.

{{baseUrl}}/quote/tags/remove

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

tags

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/tags/remove?id=&tags=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/quote/tags/remove" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                              :query-params {:id ""
                                                                             :tags ""}})

require "http/client"

url = "{{baseUrl}}/quote/tags/remove?id=&tags="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/quote/tags/remove?id=&tags="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/tags/remove?id=&tags=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/tags/remove?id=&tags="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

POST /baseUrl/quote/tags/remove?id=&tags= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/tags/remove?id=&tags=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/tags/remove?id=&tags="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/tags/remove?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/quote/tags/remove?id=&tags=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/quote/tags/remove?id=&tags=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/tags/remove',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/tags/remove?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/quote/tags/remove?id=&tags=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/tags/remove?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/tags/remove?id=&tags=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/tags/remove',
  qs: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/quote/tags/remove');

req.query({
  id: '',
  tags: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/tags/remove',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/tags/remove?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/tags/remove?id=&tags="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/tags/remove?id=&tags=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote/tags/remove?id=&tags=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/quote/tags/remove?id=&tags=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/tags/remove');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'id' => '',
  'tags' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/tags/remove');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'id' => '',
  'tags' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/tags/remove?id=&tags=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/tags/remove?id=&tags=' -Method POST -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/quote/tags/remove?id=&tags=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote/tags/remove"

querystring = {"id":"","tags":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/tags/remove"

queryString <- list(
  id = "",
  tags = ""
)

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/tags/remove?id=&tags=")

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

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.post('/baseUrl/quote/tags/remove') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
  req.params['tags'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("id", ""),
        ("tags", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/quote/tags/remove?id=&tags=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/quote/tags/remove?id=&tags=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/tags/remove?id=&tags='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/tags/remove?id=&tags=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "success": {
        "total": 1
    },
    "contents": {
        "message": "Tags removed."
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

PATCH Update a quote

{{baseUrl}}/quote

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/quote" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                   :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/quote?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/quote?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote?id=");
var request = new RestRequest("", Method.Patch);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote?id="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

PATCH /baseUrl/quote?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/quote?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote?id="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("PATCH", 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}}/quote?id=")
  .patch(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/quote?id=")
  .header("x-theysaidso-api-secret", "{{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('PATCH', '{{baseUrl}}/quote?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/quote',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote?id=';
const options = {method: 'PATCH', headers: {'x-theysaidso-api-secret': '{{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}}/quote?id=',
  method: 'PATCH',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote?id=")
  .patch(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'PATCH',
  url: '{{baseUrl}}/quote',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/quote');

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

req.headers({
  'x-theysaidso-api-secret': '{{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: 'PATCH',
  url: '{{baseUrl}}/quote',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote?id=';
const options = {method: 'PATCH', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote?id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/quote?id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/quote?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote');
$request->setRequestMethod('PATCH');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote?id=' -Method PATCH -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote?id=' -Method PATCH -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("PATCH", "/baseUrl/quote?id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.patch(url, headers=headers, params=querystring)

print(response.json())

library(httr)

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

queryString <- list(id = "")

response <- VERB("PATCH", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote?id=")

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

request = Net::HTTP::Patch.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.patch('/baseUrl/quote') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/quote?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http PATCH '{{baseUrl}}/quote?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method PATCH \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote?id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "success": {
    "total": 1
  },
  "content": {
    "quote": {
      "id": "0tztT1wYHRzdTf7jIccAzweF"
    }
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

POST Add a quote to a given Qshow.

{{baseUrl}}/qshow/quotes/add

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quoteid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/qshow/quotes/add?id="eid=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/qshow/quotes/add" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                             :query-params {:id ""
                                                                            :quoteid ""}})

require "http/client"

url = "{{baseUrl}}/qshow/quotes/add?id="eid="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/qshow/quotes/add?id="eid="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qshow/quotes/add?id="eid=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/qshow/quotes/add?id="eid="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

POST /baseUrl/qshow/quotes/add?id="eid= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/qshow/quotes/add?id="eid=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qshow/quotes/add?id="eid="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/qshow/quotes/add?id="eid=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/qshow/quotes/add?id="eid=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/qshow/quotes/add?id="eid=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/qshow/quotes/add',
  params: {id: '', quoteid: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/qshow/quotes/add?id="eid=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/qshow/quotes/add?id="eid=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qshow/quotes/add?id="eid=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qshow/quotes/add?id="eid=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/qshow/quotes/add',
  qs: {id: '', quoteid: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/qshow/quotes/add');

req.query({
  id: '',
  quoteid: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/qshow/quotes/add',
  params: {id: '', quoteid: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/qshow/quotes/add?id="eid=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/qshow/quotes/add?id="eid="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/qshow/quotes/add?id="eid=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/qshow/quotes/add?id="eid=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/qshow/quotes/add?id="eid=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/qshow/quotes/add');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'id' => '',
  'quoteid' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/qshow/quotes/add');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'id' => '',
  'quoteid' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qshow/quotes/add?id="eid=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qshow/quotes/add?id="eid=' -Method POST -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/qshow/quotes/add?id="eid=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/qshow/quotes/add"

querystring = {"id":"","quoteid":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/qshow/quotes/add"

queryString <- list(
  id = "",
  quoteid = ""
)

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qshow/quotes/add?id="eid=")

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

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.post('/baseUrl/qshow/quotes/add') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
  req.params['quoteid'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("id", ""),
        ("quoteid", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/qshow/quotes/add?id="eid=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/qshow/quotes/add?id="eid=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/qshow/quotes/add?id="eid='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qshow/quotes/add?id="eid=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "content": {
    "Quote added"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Qshow not found"
    }
}

PUT Create and add a new qshow to your private collection.

{{baseUrl}}/qshow

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

title

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/qshow?title=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/qshow" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                 :query-params {:title ""}})

require "http/client"

url = "{{baseUrl}}/qshow?title="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/qshow?title="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qshow?title=");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/qshow?title="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

PUT /baseUrl/qshow?title= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/qshow?title=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qshow?title="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/qshow?title=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/qshow?title=")
  .header("x-theysaidso-api-secret", "{{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('PUT', '{{baseUrl}}/qshow?title=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/qshow',
  params: {title: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/qshow?title=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{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}}/qshow?title=',
  method: 'PUT',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qshow?title=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qshow?title=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/qshow',
  qs: {title: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/qshow');

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

req.headers({
  'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/qshow',
  params: {title: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/qshow?title=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/qshow?title=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/qshow?title=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/qshow?title=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/qshow');
$request->setMethod(HTTP_METH_PUT);

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/qshow');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'title' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qshow?title=' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qshow?title=' -Method PUT -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("PUT", "/baseUrl/qshow?title=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/qshow"

querystring = {"title":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.put(url, headers=headers, params=querystring)

print(response.json())

library(httr)

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

queryString <- list(title = "")

response <- VERB("PUT", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qshow?title=")

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

request = Net::HTTP::Put.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.put('/baseUrl/qshow') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['title'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/qshow?title=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http PUT '{{baseUrl}}/qshow?title=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/qshow?title='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "content": {
    "quote": {
      "id": "CodzN7F_vU_URoHrPSUvDgeF"
    }
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

DELETE Delete a qshow.

{{baseUrl}}/qshow

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/qshow?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/qshow" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                    :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/qshow?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/qshow?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qshow?id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/qshow?id="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

DELETE /baseUrl/qshow?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/qshow?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qshow?id="))
    .header("x-theysaidso-api-secret", "{{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}}/qshow?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/qshow?id=")
  .header("x-theysaidso-api-secret", "{{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}}/qshow?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/qshow',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/qshow?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{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}}/qshow?id=',
  method: 'DELETE',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qshow?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qshow?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/qshow',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/qshow');

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

req.headers({
  'x-theysaidso-api-secret': '{{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}}/qshow',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/qshow?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

 "{{baseUrl}}/qshow?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/qshow?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/qshow');
$request->setMethod(HTTP_METH_DELETE);

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/qshow');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qshow?id=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qshow?id=' -Method DELETE -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/qshow?id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/qshow"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

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

queryString <- list(id = "")

response <- VERB("DELETE", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qshow?id=")

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

request = Net::HTTP::Delete.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.delete('/baseUrl/qshow') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/qshow?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http DELETE '{{baseUrl}}/qshow?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/qshow?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qshow?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/xml

RESPONSE BODY xml

{}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Qshow not found"
    }
}

GET Get the list of Qshows in They Said So platform.

{{baseUrl}}/qshow/list

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/qshow/list" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/qshow/list"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/qshow/list"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qshow/list");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/qshow/list"

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/qshow/list HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/qshow/list")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qshow/list"))
    .header("x-theysaidso-api-secret", "{{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}}/qshow/list")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/qshow/list")
  .header("x-theysaidso-api-secret", "{{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}}/qshow/list');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/qshow/list',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/qshow/list';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/qshow/list',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qshow/list")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qshow/list',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/qshow/list',
  headers: {'x-theysaidso-api-secret': '{{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}}/qshow/list');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/qshow/list',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/qshow/list';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

 "{{baseUrl}}/qshow/list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/qshow/list', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/qshow/list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qshow/list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qshow/list' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

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

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

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

import requests

url = "{{baseUrl}}/qshow/list"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/qshow/list"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qshow/list")

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/qshow/list') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/qshow/list \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/qshow/list \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/qshow/list

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qshow/list")! 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

{
    "success": {
        "total": "39",
        "start": 0,
        "limit": 5
    },
    "contents": {
        "qshows": [
            {
                "title": "A tribute to Steve Jobs!",
                "description": "A collection of great quotes from the master inventor Steve Jobs!",
                "background": "/img/bgs/stevejobs.jpg",
                "language": "en",
                "id": "CodzN7F_vU_URoHrPSUvDgeF"
            },
            {
                "title": "Celebrating Life!",
                "description": "Eat, Sleep, Live your life!",
                "background": "/img/slide-01.jpg",
                "language": "en",
                "id": "opDfpWwAD6lrfxdW_GBoVAeF"
            },
            {
                "title": "Books ",
                "description": "Reading is the greatest pleasure for many! Here's to the bookies!",
                "background": "/img/bgs/book.jpg",
                "language": "en",
                "id": "WMeCgo5WpiLk_qlbdAVyQweF"
            },
            {
                "title": "Kids",
                "description": "",
                "background": "",
                "language": "en",
                "id": "sx9reMTiaGzXdt7lbVWntQeF"
            },
            {
                "title": "Great quotes to live by",
                "description": "Here are some powerful words of wisdom that inspire, educate and motivate a person to take action. ",
                "background": "/img/slide-03.jpg",
                "language": "en",
                "id": "k_kwBr7BKzxz3vLTQ6TWMQeF"
            }
        ]
    },
    "copyright": {
        "year": "2016-18",
        "url": "http://theysaidso.com"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

GET Get the quotes in a given Qshow.

{{baseUrl}}/qshow/quotes

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/qshow/quotes?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/qshow/quotes" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                        :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/qshow/quotes?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/qshow/quotes?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qshow/quotes?id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/qshow/quotes?id="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/qshow/quotes?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/qshow/quotes?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qshow/quotes?id="))
    .header("x-theysaidso-api-secret", "{{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}}/qshow/quotes?id=")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/qshow/quotes?id=")
  .header("x-theysaidso-api-secret", "{{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}}/qshow/quotes?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/qshow/quotes',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/qshow/quotes?id=';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/qshow/quotes?id=',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qshow/quotes?id=")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qshow/quotes?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/qshow/quotes',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/qshow/quotes');

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

req.headers({
  'x-theysaidso-api-secret': '{{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}}/qshow/quotes',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/qshow/quotes?id=';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/qshow/quotes?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}}/qshow/quotes?id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/qshow/quotes?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/qshow/quotes?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qshow/quotes?id=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qshow/quotes?id=' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/qshow/quotes?id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/qshow/quotes"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/qshow/quotes"

queryString <- list(id = "")

response <- VERB("GET", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qshow/quotes?id=")

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/qshow/quotes') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/qshow/quotes?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET '{{baseUrl}}/qshow/quotes?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/qshow/quotes?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qshow/quotes?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

{
    "success": {
        "total": 1
    },
    "contents": {
        "qshow": {
            "title": "A tribute to Steve Jobs!",
            "description": "A collection of great quotes from the master inventor Steve Jobs!",
            "background": "https://theysaidso.com/img/bgs/stevejobs.jpg",
            "language": "en",
            "id": "CodzN7F_vU_URoHrPSUvDgeF"
        },
        "quotes": [
            {
                "quote": "A lot of people in our industry haven't had very diverse experiences. So they don't have enough dots to connect, and they end up with very linear solutions without a broad perspective on the problem. The broader one's understanding of the human experience, the better design we will have.",
                "length": "288",
                "author": "Steve Jobs",
                "tags": [
                    "design",
                    "diversity",
                    "experience",
                    "linear-thinking"
                ],
                "id": "6HW5Uopw8VFLRKZEqGKDXQeF"
            },
            {
                "quote": "Stay hungry. Stay foolish.",
                "length": "26",
                "author": "Steve Jobs",
                "tags": [
                    "inspirational"
                ],
                "id": "K__p_L1iMZtWulJ1SH4CogeF"
            },
            {
                "quote": "Your time is limited, so don't waste it living someone else's life.",
                "length": "67",
                "author": "Steve Jobs",
                "tags": [
                    "life-and-living",
                    "tso-life"
                ],
                "id": "mFjh_dNB_exJMHbyzRFIvQeF"
            },
            {
                "quote": "If you haven't found it yet, keep looking. Don't settle. As with all matters of the heart, you'll know when you find it. And, like any great relationship, it just gets better and better as the years roll on.",
                "length": "207",
                "author": "Steve Jobs",
                "tags": [
                    "careers",
                    "ideas",
                    "ingenuity",
                    "match",
                    "passion"
                ],
                "id": "l3Cww1Bx7cYGlIpB_wZuOAeF"
            },
            {
                "quote": "Details matter, it's worth waiting to get it right.",
                "length": "51",
                "author": "Steve Jobs",
                "tags": [
                    "apple",
                    "ileadership",
                    "jobs",
                    "mac",
                    "macintosh",
                    "steve"
                ],
                "id": "A8gqJ6u2x3ZdUDU5VlnIxgeF"
            },
            {
                "quote": "Be a yardstick of quality. Some people aren't used to an environment where excellence is expected.",
                "length": "98",
                "author": "Steve Jobs",
                "tags": [
                    "environment",
                    "excellence",
                    "people",
                    "quality"
                ],
                "id": "rlqbJLNmDMPT_qkCpDBjEgeF"
            },
            {
                "quote": "If you live each day as it was your last, someday you'll most certainly be right",
                "length": "80",
                "author": "Steve Jobs",
                "tags": [
                    "death",
                    "rip",
                    "steve",
                    "tso-life"
                ],
                "id": "sBse0_uUemQD2l_qdL9BJgeF"
            },
            {
                "quote": "Death is the destination we all share, no one has ever escaped it. And that is as it should be because death is very likely the single best invention of life.",
                "length": "158",
                "author": "Steve Jobs",
                "tags": [
                    "death",
                    "destination",
                    "invention",
                    "life-and-death",
                    "tso-life"
                ],
                "id": "LvjYLbdYzBOAqPPKfohvmQeF"
            },
            {
                "quote": "Why join the navy if you can be a pirate?",
                "length": "41",
                "author": "Steve Jobs",
                "tags": [
                    "career"
                ],
                "id": "S6xVf_Nluid5r_0iO73ArQeF"
            },
            {
                "quote": "One more thing...",
                "length": "17",
                "author": "Steve Jobs",
                "tags": [
                    "inspiration"
                ],
                "id": "X2QetehlwForyBZ5Nbp2YQeF"
            }
        ]
    },
    "copyright": {
        "year": "2016-18",
        "url": "http://theysaidso.com"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Qshow not found"
    }
}

GET Gets a details about a qshow.

{{baseUrl}}/qshow

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/qshow" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                 :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/qshow?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/qshow?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qshow?id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/qshow?id="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/qshow?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/qshow?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qshow?id="))
    .header("x-theysaidso-api-secret", "{{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}}/qshow?id=")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/qshow?id=")
  .header("x-theysaidso-api-secret", "{{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}}/qshow?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/qshow',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/qshow?id=';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/qshow?id=',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qshow?id=")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qshow?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/qshow',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/qshow');

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

req.headers({
  'x-theysaidso-api-secret': '{{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}}/qshow',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/qshow?id=';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

 "{{baseUrl}}/qshow?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/qshow?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qshow?id=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qshow?id=' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/qshow?id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/qshow"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

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

queryString <- list(id = "")

response <- VERB("GET", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qshow?id=")

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/qshow') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/qshow?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET '{{baseUrl}}/qshow?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/qshow?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qshow?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

{
    "success": {
        "total": 1
    },
    "contents": {
        "qshow": {
            "title": "A tribute to Steve Jobs!",
            "description": "A collection of great quotes from the master inventor Steve Jobs!",
            "background": "https://theysaidso.com",
            "language": "en",
            "id": "CodzN7F_vU_URoHrPSUvDgeF"
        }
    },
    "copyright": {
        "year": "2016-18",
        "url": "http://theysaidso.com"
    }
}

RESPONSE HEADERS

Content-Type

application/xml

RESPONSE BODY xml

 
  
    1
  
  
    
      A tribute to Steve Jobs!
      A collection of great quotes from the master inventor Steve Jobs!
      https://theysaidso.com
      en
      CodzN7F_vU_URoHrPSUvDgeF
    
  
  
    2016-18
    http://theysaidso.com

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Qshow not found"
    }
}

POST Remove a quote to a given Qshow.

{{baseUrl}}/qshow/quotes/remove

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quoteid

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/qshow/quotes/remove?id="eid=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/qshow/quotes/remove" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                                :query-params {:id ""
                                                                               :quoteid ""}})

require "http/client"

url = "{{baseUrl}}/qshow/quotes/remove?id="eid="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/qshow/quotes/remove?id="eid="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qshow/quotes/remove?id="eid=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/qshow/quotes/remove?id="eid="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

POST /baseUrl/qshow/quotes/remove?id="eid= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/qshow/quotes/remove?id="eid=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qshow/quotes/remove?id="eid="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/qshow/quotes/remove?id="eid=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/qshow/quotes/remove?id="eid=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/qshow/quotes/remove?id="eid=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/qshow/quotes/remove',
  params: {id: '', quoteid: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/qshow/quotes/remove?id="eid=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/qshow/quotes/remove?id="eid=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qshow/quotes/remove?id="eid=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qshow/quotes/remove?id="eid=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/qshow/quotes/remove',
  qs: {id: '', quoteid: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/qshow/quotes/remove');

req.query({
  id: '',
  quoteid: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/qshow/quotes/remove',
  params: {id: '', quoteid: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/qshow/quotes/remove?id="eid=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/qshow/quotes/remove?id="eid="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/qshow/quotes/remove?id="eid=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/qshow/quotes/remove?id="eid=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/qshow/quotes/remove?id="eid=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/qshow/quotes/remove');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'id' => '',
  'quoteid' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/qshow/quotes/remove');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'id' => '',
  'quoteid' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qshow/quotes/remove?id="eid=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qshow/quotes/remove?id="eid=' -Method POST -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/qshow/quotes/remove?id="eid=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/qshow/quotes/remove"

querystring = {"id":"","quoteid":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/qshow/quotes/remove"

queryString <- list(
  id = "",
  quoteid = ""
)

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qshow/quotes/remove?id="eid=")

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

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.post('/baseUrl/qshow/quotes/remove') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
  req.params['quoteid'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("id", ""),
        ("quoteid", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/qshow/quotes/remove?id="eid=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/qshow/quotes/remove?id="eid=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/qshow/quotes/remove?id="eid='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qshow/quotes/remove?id="eid=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "content": {
    "Quote removed from Qshow"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Qshow not found"
    }
}

PATCH Update an existing qshow.

{{baseUrl}}/qshow

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/qshow?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/qshow" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                   :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/qshow?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/qshow?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qshow?id=");
var request = new RestRequest("", Method.Patch);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/qshow?id="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

PATCH /baseUrl/qshow?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/qshow?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qshow?id="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("PATCH", 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}}/qshow?id=")
  .patch(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/qshow?id=")
  .header("x-theysaidso-api-secret", "{{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('PATCH', '{{baseUrl}}/qshow?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/qshow',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/qshow?id=';
const options = {method: 'PATCH', headers: {'x-theysaidso-api-secret': '{{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}}/qshow?id=',
  method: 'PATCH',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qshow?id=")
  .patch(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qshow?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'PATCH',
  url: '{{baseUrl}}/qshow',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/qshow');

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

req.headers({
  'x-theysaidso-api-secret': '{{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: 'PATCH',
  url: '{{baseUrl}}/qshow',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/qshow?id=';
const options = {method: 'PATCH', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/qshow?id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[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}}/qshow?id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/qshow?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/qshow?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/qshow');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/qshow');
$request->setRequestMethod('PATCH');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qshow?id=' -Method PATCH -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qshow?id=' -Method PATCH -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("PATCH", "/baseUrl/qshow?id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/qshow"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.patch(url, headers=headers, params=querystring)

print(response.json())

library(httr)

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

queryString <- list(id = "")

response <- VERB("PATCH", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qshow?id=")

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

request = Net::HTTP::Patch.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.patch('/baseUrl/qshow') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PATCH \
  --url '{{baseUrl}}/qshow?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http PATCH '{{baseUrl}}/qshow?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method PATCH \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/qshow?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qshow?id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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

{
  "success": {
    "total": 1
  },
  "content": {
    "quote": {
      "id": "CodzN7F_vU_URoHrPSUvDgeF"
    }
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Qshow not found"
    }
}

POST Dislike the given Quote as a user of the API Key. Same as `put` but a convenient alias for those clients that don't support `put` cleanly.

{{baseUrl}}/quote/dislike

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quote_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/dislike?quote_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/quote/dislike" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                          :query-params {:quote_id ""}})

require "http/client"

url = "{{baseUrl}}/quote/dislike?quote_id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/quote/dislike?quote_id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/dislike?quote_id=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/dislike?quote_id="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

POST /baseUrl/quote/dislike?quote_id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/dislike?quote_id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/dislike?quote_id="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/dislike?quote_id=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/quote/dislike?quote_id=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/quote/dislike?quote_id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/dislike',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/dislike?quote_id=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/quote/dislike?quote_id=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/dislike?quote_id=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/dislike?quote_id=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/dislike',
  qs: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/dislike',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/dislike?quote_id=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/dislike?quote_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/dislike?quote_id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote/dislike?quote_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/quote/dislike?quote_id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/dislike');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'quote_id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/dislike?quote_id=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/dislike?quote_id=' -Method POST -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/quote/dislike?quote_id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote/dislike"

querystring = {"quote_id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/dislike"

queryString <- list(quote_id = "")

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/dislike?quote_id=")

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

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.post('/baseUrl/quote/dislike') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['quote_id'] = ''
end

puts response.status
puts response.body

use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/quote/dislike?quote_id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/quote/dislike?quote_id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/dislike?quote_id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/dislike?quote_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "contents": "Disliked the quote"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

PUT Dislike the given Quote as a user of the API Key. Some clients don't cleanly support `PUT`, in such scenarios use the `POST` version of this.

{{baseUrl}}/quote/dislike

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quote_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/dislike?quote_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/quote/dislike" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                         :query-params {:quote_id ""}})

require "http/client"

url = "{{baseUrl}}/quote/dislike?quote_id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/quote/dislike?quote_id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/dislike?quote_id=");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/dislike?quote_id="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

PUT /baseUrl/quote/dislike?quote_id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/quote/dislike?quote_id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/dislike?quote_id="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/dislike?quote_id=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/quote/dislike?quote_id=")
  .header("x-theysaidso-api-secret", "{{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('PUT', '{{baseUrl}}/quote/dislike?quote_id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/quote/dislike',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/dislike?quote_id=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{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}}/quote/dislike?quote_id=',
  method: 'PUT',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/dislike?quote_id=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/dislike?quote_id=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/quote/dislike',
  qs: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/quote/dislike');

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

req.headers({
  'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/quote/dislike',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/dislike?quote_id=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/dislike?quote_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/dislike?quote_id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote/dislike?quote_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/quote/dislike?quote_id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/dislike');
$request->setMethod(HTTP_METH_PUT);

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/dislike');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'quote_id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/dislike?quote_id=' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/dislike?quote_id=' -Method PUT -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("PUT", "/baseUrl/quote/dislike?quote_id=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote/dislike"

querystring = {"quote_id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.put(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/dislike"

queryString <- list(quote_id = "")

response <- VERB("PUT", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/dislike?quote_id=")

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

request = Net::HTTP::Put.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.put('/baseUrl/quote/dislike') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['quote_id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

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

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/quote/dislike?quote_id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http PUT '{{baseUrl}}/quote/dislike?quote_id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/dislike?quote_id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/dislike?quote_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "contents": "Disliked the quote"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

GET Gets a `Quote` with a given `id`.

{{baseUrl}}/quote

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/quote" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

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

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/quote HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote"))
    .header("x-theysaidso-api-secret", "{{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}}/quote")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/quote")
  .header("x-theysaidso-api-secret", "{{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}}/quote');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

 "{{baseUrl}}/quote",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/quote', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

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

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

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

import requests

url = "{{baseUrl}}/quote"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/quote') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote")! 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

{
  "success": {
    "total": 1
  },
  "contents": {
    "quote": "The day soldiers stop bringing you their problems is the day you have stopped leading them. They have either lost confidence that you can help them or concluded that you do not care. Either case is a failure of leadership.",
    "author": "Colin Powell",
    "id": "XLa1AmylKv1XF_dXcyhvdweF",
    "language": "en",
    "sfw": "sfw",
    "permalink": "https://theysaidso.com/quote/colin-powell-the-day-soldiers-stop-bringing-you-their-problems-is-the-day-you-ha",
    "requested_category": "inspire",
    "categories": [
      "confidence",
      "leadership",
      "management",
      "tod"
    ]
  }
}

RESPONSE HEADERS

Content-Type

application/xml

RESPONSE BODY xml

 
  
    1
  
  
    
      Sometimes you climb out of bed in the morning and you think, I'm not going to make it, but you laugh inside — remembering all the times you've felt that way.
      164
      Charles Bukowski
      depression
      inspire
      tso-life
      inspire
      2016-11-23
      Inspiring Quote of the day
      https://theysaidso.com/img/bgs/man_on_the_mountain.jpg
      k7rTMtmveYHUN2ImwxNhhAeF

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

GET Gets a `Random Quote`. When you are in a hurry this is what you call to get a random famous quote.

{{baseUrl}}/quote/random

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/quote/random" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/random"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/random"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/random");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/random"

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/quote/random HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/random")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/random"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/random")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/quote/random")
  .header("x-theysaidso-api-secret", "{{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}}/quote/random');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/random',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/random';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/random',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/random")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/random',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/random',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/random');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/random',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/random';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

 "{{baseUrl}}/quote/random",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/quote/random', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/random');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/random' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/random' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

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

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

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

import requests

url = "{{baseUrl}}/quote/random"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/random"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/random")

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/quote/random') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/random \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/random \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/random

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/random")! 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

{
    "success": {
        "total": 1
    },
    "contents": {
        "quotes": [
            {
                "quote": "The day soldiers stop bringing you their problems is the day you have stopped leading them. They have either lost confidence that you can help them or concluded that you do not care. Either case is a failure of leadership.",
                "length": "222",
                "author": "Colin Powell",
                "tags": [
                    "confidence",
                    "leadership",
                    "management"
                ],
                "category": "management",
                "id": "XLa1AmylKv1XF_dXcyhvdweF"
            }
        ]
    }
}

RESPONSE HEADERS

Content-Type

application/xml

RESPONSE BODY xml

 
  
    1
  
  
    
      Sometimes you climb out of bed in the morning and you think, I'm not going to make it, but you laugh inside — remembering all the times you've felt that way.
      164
      Charles Bukowski
      depression
      inspire
      tso-life
      inspire
      2016-11-23
      Inspiring Quote of the day
      https://theysaidso.com/img/bgs/man_on_the_mountain.jpg
      k7rTMtmveYHUN2ImwxNhhAeF

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

GET Gets a list of `Quote` Categories matching the query string.

{{baseUrl}}/quote/categories/search

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/categories/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/quote/categories/search" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/categories/search"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/categories/search"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/categories/search");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/categories/search"

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/quote/categories/search HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/categories/search")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/categories/search"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/categories/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/quote/categories/search")
  .header("x-theysaidso-api-secret", "{{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}}/quote/categories/search');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/categories/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/categories/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/categories/search',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/categories/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/categories/search',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/categories/search',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/categories/search');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/categories/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/categories/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/categories/search"]
                                                       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}}/quote/categories/search" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote/categories/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/quote/categories/search', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/categories/search');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/categories/search' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/categories/search' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/categories/search", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote/categories/search"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/categories/search")

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/quote/categories/search') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/categories/search \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/categories/search \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/categories/search

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/categories/search")! 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

{
  "success": {
    "total": 34,
    "range": {
      "start": 0,
      "end": 5
    }
  },
  "contents": {
    "categories": [
      {
        "name": "inspire",
        "title": null
      },
      {
        "name": "inspired",
        "title": null
      },
      {
        "name": "words-to-inspire-you",
        "title": null
      },
      {
        "name": "self-inspired",
        "title": null
      },
      {
        "name": "inspire-the-world",
        "title": null
      }
    ]
  },
  "baseurl": "https://theysaidso.com",
  "copyright": "2019-22 https://theysaidso.com"
}

GET Gets a list of author names in the system.

{{baseUrl}}/quote/authors/search

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/authors/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/quote/authors/search" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/authors/search"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/authors/search"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/authors/search");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/authors/search"

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/quote/authors/search HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/authors/search")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/authors/search"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/authors/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/quote/authors/search")
  .header("x-theysaidso-api-secret", "{{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}}/quote/authors/search');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/authors/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/authors/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/authors/search',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/authors/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/authors/search',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/authors/search',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/authors/search');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/authors/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/authors/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/authors/search"]
                                                       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}}/quote/authors/search" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote/authors/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/quote/authors/search', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/authors/search');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/authors/search');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/authors/search' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/authors/search' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/authors/search", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote/authors/search"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/authors/search"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/authors/search")

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/quote/authors/search') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/authors/search \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/authors/search \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/authors/search

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/authors/search")! 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

{
  "success": {
    "total": "2646",
    "range": {
      "start": 0,
      "end": 5
    }
  },
  "contents": {
    "authors": [
      {
        "name": "Robert Louis Stevenson",
        "slug": "robert-louis-stevenson",
        "occupation": "Author",
        "born": "1850-11-13 00:00:00",
        "dead": "1894-12-03 00:00:00",
        "description": null,
        "id": "_kobR6QdDXDw_HCo2J_n0AeF"
      },
      {
        "name": "Steve Jobs",
        "slug": "steve-jobs",
        "occupation": "Business",
        "born": "1955-02-24 00:00:00",
        "dead": "2011-10-05 00:00:00",
        "description": "",
        "id": "WKCl3utqIPYnCXiZubNNKAeF"
      },
      {
        "name": "Steve Maraboli",
        "slug": "steve-maraboli",
        "occupation": null,
        "born": null,
        "dead": null,
        "description": null,
        "id": "GfOeOBX2Gwp1emdunDiXDweF"
      },
      {
        "name": "Steven Wright",
        "slug": "steven-wright",
        "occupation": "Comic",
        "born": "1955-12-06 00:00:00",
        "dead": null,
        "description": null,
        "id": "j144PP_Pew72rXVrRKAmgAeF"
      },
      {
        "name": "Wallace Stevens",
        "slug": "wallace-stevens",
        "occupation": "Poet",
        "born": "1879-10-02 00:00:00",
        "dead": "1955-08-02 00:00:00",
        "description": null,
        "id": "IF8HZp3hHsP_BzepN65atQeF"
      }
    ],
    "matched_query": "steve"
  },
  "baseurl": "https://theysaidso.com",
  "copyright": "2019-22 https://theysaidso.com"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": {
    "code": 400,
    "message": "Bad Request: Author details retrieval options are not supported for this user (please upgrade your subscription)"
  }
}

GET Gets a list of popular `Quote` Categories.

{{baseUrl}}/quote/categories/popular

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/categories/popular");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/quote/categories/popular" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/categories/popular"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/categories/popular"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/categories/popular");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/categories/popular"

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/quote/categories/popular HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/categories/popular")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/categories/popular"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/categories/popular")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/quote/categories/popular")
  .header("x-theysaidso-api-secret", "{{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}}/quote/categories/popular');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/categories/popular',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/categories/popular';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/categories/popular',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/categories/popular")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/categories/popular',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/categories/popular',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/categories/popular');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/categories/popular',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/categories/popular';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/categories/popular" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote/categories/popular",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/quote/categories/popular', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/categories/popular');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/categories/popular' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/categories/popular' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/categories/popular", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote/categories/popular"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/categories/popular")

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/quote/categories/popular') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/categories/popular \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/categories/popular \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/categories/popular

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 18,
    "range": {
      "start": 0,
      "end": 5
    }
  },
  "contents": {
    "categories": [
      {
        "name": "inspirational",
        "title": "Inspirational Quotes"
      },
      {
        "name": "work",
        "title": null
      },
      {
        "name": "women",
        "title": null
      },
      {
        "name": "people",
        "title": null
      },
      {
        "name": "death",
        "title": null
      }
    ]
  },
  "baseurl": "https://theysaidso.com",
  "copyright": "2019-22 https://theysaidso.com"
}

GET Gets a list of popular author names in the system.

{{baseUrl}}/quote/authors/popular

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/authors/popular");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/quote/authors/popular" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/authors/popular"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/authors/popular"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/authors/popular");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/authors/popular"

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

GET /baseUrl/quote/authors/popular HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/authors/popular")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/authors/popular"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/authors/popular")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/quote/authors/popular")
  .header("x-theysaidso-api-secret", "{{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}}/quote/authors/popular');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/authors/popular',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/authors/popular';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/authors/popular',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/authors/popular")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/authors/popular',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/authors/popular',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/authors/popular');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/authors/popular',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/authors/popular';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/authors/popular" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote/authors/popular",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/quote/authors/popular', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/authors/popular');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/authors/popular');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/authors/popular' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/authors/popular' -Method GET -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/authors/popular", headers=headers)

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

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

import requests

url = "{{baseUrl}}/quote/authors/popular"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/authors/popular"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/authors/popular")

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

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/quote/authors/popular') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/authors/popular \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/authors/popular \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/authors/popular

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

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

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

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": "2646",
    "range": {
      "start": 0,
      "end": 5
    }
  },
  "contents": {
    "authors": [
      {
        "name": "Robert Louis Stevenson",
        "slug": "robert-louis-stevenson",
        "occupation": "Author",
        "born": "1850-11-13 00:00:00",
        "dead": "1894-12-03 00:00:00",
        "description": null,
        "id": "_kobR6QdDXDw_HCo2J_n0AeF"
      },
      {
        "name": "Steve Jobs",
        "slug": "steve-jobs",
        "occupation": "Business",
        "born": "1955-02-24 00:00:00",
        "dead": "2011-10-05 00:00:00",
        "description": "",
        "id": "WKCl3utqIPYnCXiZubNNKAeF"
      },
      {
        "name": "Steve Maraboli",
        "slug": "steve-maraboli",
        "occupation": null,
        "born": null,
        "dead": null,
        "description": null,
        "id": "GfOeOBX2Gwp1emdunDiXDweF"
      },
      {
        "name": "Steven Wright",
        "slug": "steven-wright",
        "occupation": "Comic",
        "born": "1955-12-06 00:00:00",
        "dead": null,
        "description": null,
        "id": "j144PP_Pew72rXVrRKAmgAeF"
      },
      {
        "name": "Wallace Stevens",
        "slug": "wallace-stevens",
        "occupation": "Poet",
        "born": "1879-10-02 00:00:00",
        "dead": "1955-08-02 00:00:00",
        "description": null,
        "id": "IF8HZp3hHsP_BzepN65atQeF"
      }
    ],
    "matched_query": "steve"
  },
  "baseurl": "https://theysaidso.com",
  "copyright": "2019-22 https://theysaidso.com"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": {
    "code": 400,
    "message": "Bad Request: Author details retrieval options are not supported for this user (please upgrade your subscription)"
  }
}

POST Like the given Quote as a user of the API Key. Same as `PUT` but a convenient alias for those clients that don't support `PUT` cleanly.

{{baseUrl}}/quote/like

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quote_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/like?quote_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/quote/like" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                       :query-params {:quote_id ""}})

require "http/client"

url = "{{baseUrl}}/quote/like?quote_id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/quote/like?quote_id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/like?quote_id=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/quote/like?quote_id="

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

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

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

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

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

}

POST /baseUrl/quote/like?quote_id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/like?quote_id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/like?quote_id="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/like?quote_id=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/quote/like?quote_id=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/quote/like?quote_id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/like',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/quote/like?quote_id=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/quote/like?quote_id=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/like?quote_id=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/like?quote_id=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/like',
  qs: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/like',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/quote/like?quote_id=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/like?quote_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/like?quote_id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

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

 "{{baseUrl}}/quote/like?quote_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/quote/like?quote_id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

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

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

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/quote/like');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'quote_id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/like?quote_id=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/like?quote_id=' -Method POST -Headers $headers

import http.client

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

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/quote/like?quote_id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/like"

querystring = {"quote_id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/like"

queryString <- list(quote_id = "")

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/like?quote_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/quote/like') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['quote_id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/like";

    let querystring = [
        ("quote_id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/quote/like?quote_id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/quote/like?quote_id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/like?quote_id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/like?quote_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "contents": {
    "message": "Like added to the quote"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

PUT Like the given Quote as a user of the API Key. Some clients don't cleanly support `PUT`, in such scenarios use the `POST` version of this.

{{baseUrl}}/quote/like

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quote_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/like?quote_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/quote/like" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                      :query-params {:quote_id ""}})

require "http/client"

url = "{{baseUrl}}/quote/like?quote_id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/quote/like?quote_id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/like?quote_id=");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/like?quote_id="

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/quote/like?quote_id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/quote/like?quote_id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/like?quote_id="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/like?quote_id=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/quote/like?quote_id=")
  .header("x-theysaidso-api-secret", "{{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('PUT', '{{baseUrl}}/quote/like?quote_id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/quote/like',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/like?quote_id=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{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}}/quote/like?quote_id=',
  method: 'PUT',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/like?quote_id=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/like?quote_id=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/quote/like',
  qs: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/quote/like');

req.query({
  quote_id: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/quote/like',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/like?quote_id=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/like?quote_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/like?quote_id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/like?quote_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/quote/like?quote_id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/like');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'quote_id' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/like');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'quote_id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/like?quote_id=' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/like?quote_id=' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("PUT", "/baseUrl/quote/like?quote_id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/like"

querystring = {"quote_id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.put(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/like"

queryString <- list(quote_id = "")

response <- VERB("PUT", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/like?quote_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/quote/like') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['quote_id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/like";

    let querystring = [
        ("quote_id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/quote/like?quote_id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http PUT '{{baseUrl}}/quote/like?quote_id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/like?quote_id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/like?quote_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "contents": {
    "message": "Like added to the quote"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

DELETE Remove the Like for the given Quote as a user of the API Key.

{{baseUrl}}/quote/like

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quote_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/like?quote_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/quote/like" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                         :query-params {:quote_id ""}})

require "http/client"

url = "{{baseUrl}}/quote/like?quote_id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/like?quote_id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/like?quote_id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/like?quote_id="

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/quote/like?quote_id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/quote/like?quote_id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/like?quote_id="))
    .header("x-theysaidso-api-secret", "{{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}}/quote/like?quote_id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/quote/like?quote_id=")
  .header("x-theysaidso-api-secret", "{{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}}/quote/like?quote_id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/quote/like',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/like?quote_id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{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}}/quote/like?quote_id=',
  method: 'DELETE',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/like?quote_id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/like?quote_id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/like',
  qs: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/like');

req.query({
  quote_id: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/like',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/like?quote_id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/like?quote_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}}/quote/like?quote_id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/like?quote_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/quote/like?quote_id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/like');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'quote_id' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/like');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'quote_id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/like?quote_id=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/like?quote_id=' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/quote/like?quote_id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/like"

querystring = {"quote_id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.delete(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/like"

queryString <- list(quote_id = "")

response <- VERB("DELETE", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/like?quote_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/quote/like') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['quote_id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/like";

    let querystring = [
        ("quote_id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/quote/like?quote_id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http DELETE '{{baseUrl}}/quote/like?quote_id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/like?quote_id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/like?quote_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

{
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "contents": "Like / Dislike removed from quote."
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

DELETE Remove the disLike for the given Quote as a user of the API Key.

{{baseUrl}}/quote/dislike

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quote_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/dislike?quote_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/quote/dislike" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                            :query-params {:quote_id ""}})

require "http/client"

url = "{{baseUrl}}/quote/dislike?quote_id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/dislike?quote_id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/dislike?quote_id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/dislike?quote_id="

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/quote/dislike?quote_id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/quote/dislike?quote_id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/dislike?quote_id="))
    .header("x-theysaidso-api-secret", "{{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}}/quote/dislike?quote_id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/quote/dislike?quote_id=")
  .header("x-theysaidso-api-secret", "{{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}}/quote/dislike?quote_id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/quote/dislike',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/dislike?quote_id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{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}}/quote/dislike?quote_id=',
  method: 'DELETE',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/dislike?quote_id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/dislike?quote_id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/dislike',
  qs: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/dislike');

req.query({
  quote_id: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/dislike',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/dislike?quote_id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/dislike?quote_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}}/quote/dislike?quote_id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/dislike?quote_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/quote/dislike?quote_id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/dislike');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'quote_id' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/dislike');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'quote_id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/dislike?quote_id=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/dislike?quote_id=' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/quote/dislike?quote_id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/dislike"

querystring = {"quote_id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.delete(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/dislike"

queryString <- list(quote_id = "")

response <- VERB("DELETE", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/dislike?quote_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/quote/dislike') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['quote_id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/dislike";

    let querystring = [
        ("quote_id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/quote/dislike?quote_id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http DELETE '{{baseUrl}}/quote/dislike?quote_id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/dislike?quote_id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/dislike?quote_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

{
  "success": {
    "total": 1
  },
  "contents": "Like / Dislike removed from quote."
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

GET Search for a `Quote` in They Said So platform. Optional `category` , `author`, `minlength`, `maxlength` params determines the filters applied while searching for the quote.

{{baseUrl}}/quote/search

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/quote/search" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/search"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/search"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/search");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/search"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/quote/search HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/search")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/search"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/quote/search")
  .header("x-theysaidso-api-secret", "{{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}}/quote/search');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/search',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/search',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/search',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/search');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/search"]
                                                       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}}/quote/search" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/quote/search', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/search');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/search');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/search' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/search' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/search", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/search"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/search"

response <- VERB("GET", url, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/quote/search') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/search";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/search \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/search \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/search

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/search")! 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

{
    "success": {
        "total": 1
    },
    "contents": {
        "quotes": [
            {
                "quote": "The day soldiers stop bringing you their problems is the day you have stopped leading them. They have either lost confidence that you can help them or concluded that you do not care. Either case is a failure of leadership.",
                "length": "222",
                "author": "Colin Powell",
                "tags": [
                    "confidence",
                    "leadership",
                    "management"
                ],
                "category": "management",
                "id": "XLa1AmylKv1XF_dXcyhvdweF"
            }
        ]
    }
}

RESPONSE HEADERS

Content-Type

application/xml

RESPONSE BODY xml

 
  
    1
  
  
    
      Sometimes you climb out of bed in the morning and you think, I'm not going to make it, but you laugh inside — remembering all the times you've felt that way.
      164
      Charles Bukowski
      depression
      inspire
      tso-life
      inspire
      2016-11-23
      Inspiring Quote of the day
      https://theysaidso.com/img/bgs/man_on_the_mountain.jpg
      k7rTMtmveYHUN2ImwxNhhAeF

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "No Quote found matching the search filters. Try with different search filters."
    }
}

POST Add a font file for use later in creating a quote image. This is essentially a `PUT` but not many clients handle PUT with binary stream i.e. a file, gracefully.

{{baseUrl}}/quote/image/font

HEADERS

X-TheySaidSo-Api-Secret

BODY multipartForm

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/font");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/quote/image/font" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                             :multipart [{:name "font"
                                                                          :content ""} {:name "tags"
                                                                          :content ""}]})

require "http/client"

url = "{{baseUrl}}/quote/image/font"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/quote/image/font"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "font",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "tags",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/font");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/font"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")
	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/quote/image/font HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 193

-----011000010111000001101001
Content-Disposition: form-data; name="font"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/image/font")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/font"))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/image/font")
  .post(body)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/quote/image/font")
  .header("x-theysaidso-api-secret", "{{apiKey}}")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

const data = new FormData();
data.append('font', '');
data.append('tags', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/quote/image/font');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const form = new FormData();
form.append('font', '');
form.append('tags', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/image/font',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/font';
const form = new FormData();
form.append('font', '');
form.append('tags', '');

const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const form = new FormData();
form.append('font', '');
form.append('tags', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/quote/image/font',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  },
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/font")
  .post(body)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/font',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="font"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="tags"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/image/font',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  formData: {font: '', tags: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/quote/image/font');

req.headers({
  'x-theysaidso-api-secret': '{{apiKey}}',
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/quote/image/font',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="font"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="tags"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('font', '');
formData.append('tags', '');

const url = '{{baseUrl}}/quote/image/font';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};
options.body = formData;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}",
                           @"content-type": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"font", @"value": @"" },
                         @{ @"name": @"tags", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/font"]
                                                       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}}/quote/image/font" in
let headers = Header.add_list (Header.init ()) [
  ("x-theysaidso-api-secret", "{{apiKey}}");
  ("content-type", "multipart/form-data; boundary=---011000010111000001101001");
] in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/font",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001",
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/quote/image/font', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/font');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}',
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="font"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/quote/image/font');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/font' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="font"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--
'

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/font' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="font"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--
'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = {
    'x-theysaidso-api-secret': "{{apiKey}}",
    'content-type': "multipart/form-data; boundary=---011000010111000001101001"
}

conn.request("POST", "/baseUrl/quote/image/font", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/font"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {
    "x-theysaidso-api-secret": "{{apiKey}}",
    "content-type": "multipart/form-data; boundary=---011000010111000001101001"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/font"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("multipart/form-data"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/font")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/quote/image/font') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"font\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/font";

    let form = reqwest::multipart::Form::new()
        .text("font", "")
        .text("tags", "");
    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/quote/image/font \
  --header 'content-type: multipart/form-data' \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --form font= \
  --form tags=

echo '-----011000010111000001101001
Content-Disposition: form-data; name="font"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/quote/image/font \
  content-type:'multipart/form-data; boundary=---011000010111000001101001' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="font"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="tags"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/quote/image/font

import Foundation

let headers = [
  "x-theysaidso-api-secret": "{{apiKey}}",
  "content-type": "multipart/form-data; boundary=---011000010111000001101001"
]
let parameters = [
  [
    "name": "font",
    "value": ""
  ],
  [
    "name": "tags",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/font")! 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

{
  "success": {
    "total": 1
  },
  "content": {
     "id" : "afBLte5678bnzxc_iRbcg"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

POST Add a tag to a given Image.

{{baseUrl}}/quote/image/background/tags/add

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

tags

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/background/tags/add?id=&tags=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/quote/image/background/tags/add" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                                            :query-params {:id ""
                                                                                           :tags ""}})

require "http/client"

url = "{{baseUrl}}/quote/image/background/tags/add?id=&tags="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/quote/image/background/tags/add?id=&tags="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/background/tags/add?id=&tags=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/background/tags/add?id=&tags="

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/quote/image/background/tags/add?id=&tags= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/image/background/tags/add?id=&tags=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/background/tags/add?id=&tags="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/image/background/tags/add?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/quote/image/background/tags/add?id=&tags=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/quote/image/background/tags/add?id=&tags=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/image/background/tags/add',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/background/tags/add?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/background/tags/add?id=&tags=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/background/tags/add?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/background/tags/add?id=&tags=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/image/background/tags/add',
  qs: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/quote/image/background/tags/add');

req.query({
  id: '',
  tags: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/image/background/tags/add',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/background/tags/add?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/background/tags/add?id=&tags="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/image/background/tags/add?id=&tags=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/background/tags/add?id=&tags=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/quote/image/background/tags/add?id=&tags=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/background/tags/add');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'id' => '',
  'tags' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/background/tags/add');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'id' => '',
  'tags' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/background/tags/add?id=&tags=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/background/tags/add?id=&tags=' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/quote/image/background/tags/add?id=&tags=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/background/tags/add"

querystring = {"id":"","tags":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/background/tags/add"

queryString <- list(
  id = "",
  tags = ""
)

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/background/tags/add?id=&tags=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/quote/image/background/tags/add') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
  req.params['tags'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/background/tags/add";

    let querystring = [
        ("id", ""),
        ("tags", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/quote/image/background/tags/add?id=&tags=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/quote/image/background/tags/add?id=&tags=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/image/background/tags/add?id=&tags='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/background/tags/add?id=&tags=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Image not found"
    }
}

POST Add a tag to a given font.

{{baseUrl}}/quote/image/font/tags/add

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

tags

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/font/tags/add?id=&tags=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/quote/image/font/tags/add" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                                      :query-params {:id ""
                                                                                     :tags ""}})

require "http/client"

url = "{{baseUrl}}/quote/image/font/tags/add?id=&tags="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/quote/image/font/tags/add?id=&tags="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/font/tags/add?id=&tags=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/font/tags/add?id=&tags="

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/quote/image/font/tags/add?id=&tags= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/image/font/tags/add?id=&tags=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/font/tags/add?id=&tags="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/image/font/tags/add?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/quote/image/font/tags/add?id=&tags=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/quote/image/font/tags/add?id=&tags=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/image/font/tags/add',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/font/tags/add?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/font/tags/add?id=&tags=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/font/tags/add?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/font/tags/add?id=&tags=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/image/font/tags/add',
  qs: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/quote/image/font/tags/add');

req.query({
  id: '',
  tags: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/image/font/tags/add',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/font/tags/add?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/font/tags/add?id=&tags="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/image/font/tags/add?id=&tags=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/font/tags/add?id=&tags=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/quote/image/font/tags/add?id=&tags=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/font/tags/add');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'id' => '',
  'tags' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/font/tags/add');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'id' => '',
  'tags' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/font/tags/add?id=&tags=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/font/tags/add?id=&tags=' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/quote/image/font/tags/add?id=&tags=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/font/tags/add"

querystring = {"id":"","tags":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/font/tags/add"

queryString <- list(
  id = "",
  tags = ""
)

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/font/tags/add?id=&tags=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/quote/image/font/tags/add') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
  req.params['tags'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/font/tags/add";

    let querystring = [
        ("id", ""),
        ("tags", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/quote/image/font/tags/add?id=&tags=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/quote/image/font/tags/add?id=&tags=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/image/font/tags/add?id=&tags='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/font/tags/add?id=&tags=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: font not found"
    }
}

POST Add an image for use later as a quote background image.

{{baseUrl}}/quote/image/background

HEADERS

X-TheySaidSo-Api-Secret

BODY multipartForm

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/background");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/quote/image/background" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                                   :multipart [{:name "image"
                                                                                :content ""} {:name "tags"
                                                                                :content ""}]})

require "http/client"

url = "{{baseUrl}}/quote/image/background"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\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}}/quote/image/background"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "image",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "tags",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/background");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/background"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")
	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/quote/image/background HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 194

-----011000010111000001101001
Content-Disposition: form-data; name="image"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/image/background")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/background"))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/image/background")
  .post(body)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/quote/image/background")
  .header("x-theysaidso-api-secret", "{{apiKey}}")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

const data = new FormData();
data.append('image', '');
data.append('tags', '');

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/quote/image/background');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const form = new FormData();
form.append('image', '');
form.append('tags', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/image/background',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/background';
const form = new FormData();
form.append('image', '');
form.append('tags', '');

const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const form = new FormData();
form.append('image', '');
form.append('tags', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/quote/image/background',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  },
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/background")
  .post(body)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/background',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="image"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="tags"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/image/background',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  formData: {image: '', tags: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/quote/image/background');

req.headers({
  'x-theysaidso-api-secret': '{{apiKey}}',
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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}}/quote/image/background',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="image"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="tags"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('image', '');
formData.append('tags', '');

const url = '{{baseUrl}}/quote/image/background';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};
options.body = formData;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}",
                           @"content-type": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"image", @"value": @"" },
                         @{ @"name": @"tags", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/background"]
                                                       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}}/quote/image/background" in
let headers = Header.add_list (Header.init ()) [
  ("x-theysaidso-api-secret", "{{apiKey}}");
  ("content-type", "multipart/form-data; boundary=---011000010111000001101001");
] in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/background",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001",
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/quote/image/background', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/background');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}',
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="image"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/quote/image/background');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/background' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="image"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--
'

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/background' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="image"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--
'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = {
    'x-theysaidso-api-secret': "{{apiKey}}",
    'content-type': "multipart/form-data; boundary=---011000010111000001101001"
}

conn.request("POST", "/baseUrl/quote/image/background", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/background"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {
    "x-theysaidso-api-secret": "{{apiKey}}",
    "content-type": "multipart/form-data; boundary=---011000010111000001101001"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/background"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("multipart/form-data"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/background")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/quote/image/background') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"tags\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/background";

    let form = reqwest::multipart::Form::new()
        .text("image", "")
        .text("tags", "");
    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/quote/image/background \
  --header 'content-type: multipart/form-data' \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --form image= \
  --form tags=

echo '-----011000010111000001101001
Content-Disposition: form-data; name="image"


-----011000010111000001101001
Content-Disposition: form-data; name="tags"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/quote/image/background \
  content-type:'multipart/form-data; boundary=---011000010111000001101001' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="image"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="tags"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/quote/image/background

import Foundation

let headers = [
  "x-theysaidso-api-secret": "{{apiKey}}",
  "content-type": "multipart/form-data; boundary=---011000010111000001101001"
]
let parameters = [
  [
    "name": "image",
    "value": ""
  ],
  [
    "name": "tags",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/background")! 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

{
  "success": {
    "total": 1
  },
  "content": {
     "id" : "afBLte5678bnzxc_iRbcg"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

PUT Create a new quote image for a given quote. Choose background colors-images , choose different font styles and generate a beautiful quote image. Did you just had a feeling of being a god or what-!

{{baseUrl}}/quote/image

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

quote_id

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image?quote_id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/quote/image" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                       :query-params {:quote_id ""}})

require "http/client"

url = "{{baseUrl}}/quote/image?quote_id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

response = HTTP::Client.put url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/quote/image?quote_id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image?quote_id=");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image?quote_id="

	req, _ := http.NewRequest("PUT", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/quote/image?quote_id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/quote/image?quote_id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image?quote_id="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/image?quote_id=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/quote/image?quote_id=")
  .header("x-theysaidso-api-secret", "{{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('PUT', '{{baseUrl}}/quote/image?quote_id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/quote/image',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image?quote_id=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image?quote_id=',
  method: 'PUT',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image?quote_id=")
  .put(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image?quote_id=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/quote/image',
  qs: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/quote/image');

req.query({
  quote_id: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'PUT',
  url: '{{baseUrl}}/quote/image',
  params: {quote_id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image?quote_id=';
const options = {method: 'PUT', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image?quote_id="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/image?quote_id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image?quote_id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/quote/image?quote_id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'quote_id' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'quote_id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image?quote_id=' -Method PUT -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image?quote_id=' -Method PUT -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("PUT", "/baseUrl/quote/image?quote_id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image"

querystring = {"quote_id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.put(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image"

queryString <- list(quote_id = "")

response <- VERB("PUT", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image?quote_id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/quote/image') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['quote_id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image";

    let querystring = [
        ("quote_id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/quote/image?quote_id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http PUT '{{baseUrl}}/quote/image?quote_id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method PUT \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/image?quote_id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image?quote_id=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 1
  },
  "contents": {
      "id": "75c3EoOmPVolqfB4KeUhXgeF",
  },
  "copyright": "2019-22 https://theysaidso.com"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote image not found"
    }
}

DELETE Delete a background image file. The user needs to be the owner of the background image to be able to delete it.

{{baseUrl}}/quote/image/background

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/background?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/quote/image/background" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                                     :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/quote/image/background?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/image/background?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/background?id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/background?id="

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/quote/image/background?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/quote/image/background?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/background?id="))
    .header("x-theysaidso-api-secret", "{{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}}/quote/image/background?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/quote/image/background?id=")
  .header("x-theysaidso-api-secret", "{{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}}/quote/image/background?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/quote/image/background',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/background?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/background?id=',
  method: 'DELETE',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/background?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/background?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/image/background',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/background');

req.query({
  id: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/image/background',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/background?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/background?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}}/quote/image/background?id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/background?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/quote/image/background?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/background');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'id' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/background');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/background?id=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/background?id=' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/quote/image/background?id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/background"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.delete(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/background"

queryString <- list(id = "")

response <- VERB("DELETE", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/background?id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/quote/image/background') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/background";

    let querystring = [
        ("id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/quote/image/background?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http DELETE '{{baseUrl}}/quote/image/background?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/image/background?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/background?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/xml

RESPONSE BODY xml

{
  "success": {
    "total": 1
  },
  "content": "Resource Deleted"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Resource not found"
    }
}

DELETE Delete a font file. The user needs to be the owner of the font to be able to delete it.

{{baseUrl}}/quote/image/font

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/font?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/quote/image/font" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                               :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/quote/image/font?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/image/font?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/font?id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/font?id="

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/quote/image/font?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/quote/image/font?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/font?id="))
    .header("x-theysaidso-api-secret", "{{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}}/quote/image/font?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/quote/image/font?id=")
  .header("x-theysaidso-api-secret", "{{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}}/quote/image/font?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/quote/image/font',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/font?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/font?id=',
  method: 'DELETE',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/font?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/font?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/image/font',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/font');

req.query({
  id: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/image/font',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/font?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/font?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}}/quote/image/font?id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/font?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/quote/image/font?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/font');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'id' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/font');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/font?id=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/font?id=' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/quote/image/font?id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/font"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.delete(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/font"

queryString <- list(id = "")

response <- VERB("DELETE", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/font?id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/quote/image/font') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/font";

    let querystring = [
        ("id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/quote/image/font?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http DELETE '{{baseUrl}}/quote/image/font?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/image/font?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/font?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/xml

RESPONSE BODY xml

{
  "success": {
    "total": 1
  },
  "content": "Resource Deleted"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Resource not found"
    }
}

DELETE Delete a quote image. The user needs to be the owner of the quote image to be able to delete it.

{{baseUrl}}/quote/image

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/quote/image" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                          :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/quote/image?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/image?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image?id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image?id="

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/quote/image?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/quote/image?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image?id="))
    .header("x-theysaidso-api-secret", "{{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}}/quote/image?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/quote/image?id=")
  .header("x-theysaidso-api-secret", "{{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}}/quote/image?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/quote/image',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image?id=',
  method: 'DELETE',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image?id=")
  .delete(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/image',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/image');

req.query({
  id: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/image',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image?id=';
const options = {method: 'DELETE', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image?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}}/quote/image?id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/quote/image?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'id' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image?id=' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image?id=' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("DELETE", "/baseUrl/quote/image?id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.delete(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image"

queryString <- list(id = "")

response <- VERB("DELETE", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image?id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/quote/image') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image";

    let querystring = [
        ("id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/quote/image?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http DELETE '{{baseUrl}}/quote/image?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method DELETE \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/image?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image?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/xml

RESPONSE BODY xml

{}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote not found"
    }
}

GET Gets a Quote image for a given id. Response can be an image file as a binary or a base64 encoded contents wrapped in json. `TODO`

{{baseUrl}}/quote/image

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image?id=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/quote/image" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                       :query-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/quote/image?id="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/image?id="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image?id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image?id="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/quote/image?id= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/image?id=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image?id="))
    .header("x-theysaidso-api-secret", "{{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}}/quote/image?id=")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/quote/image?id=")
  .header("x-theysaidso-api-secret", "{{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}}/quote/image?id=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/image',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image?id=';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image?id=',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image?id=")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image?id=',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/image',
  qs: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/image');

req.query({
  id: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/image',
  params: {id: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image?id=';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image?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}}/quote/image?id=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image?id=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/quote/image?id=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'id' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'id' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image?id=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image?id=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/image?id=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image"

querystring = {"id":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image"

queryString <- list(id = "")

response <- VERB("GET", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image?id=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/quote/image') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image";

    let querystring = [
        ("id", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/quote/image?id=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET '{{baseUrl}}/quote/image?id=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/image?id='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image?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

{
  "success": {
    "total": 1
  },
  "contents": {
    "qimage": {
      "id": "75c3EoOmPVolqfB4KeUhXgeF",
      "quote_id": "5e0QH_0k5srOUN1Wdu9AgweF",
      "permalink": "https://theysaidso.com/i/75c3EoOmPVolqfB4KeUhXgeF",
      "download_uri": "https://theysaidso.com/i/image/75c3EoOmPVolqfB4KeUhXgeF"
    }
  },
  "copyright": "2019-22 https://theysaidso.com"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote image not found"
    }
}

GET Gets a Random Quote image. Optional `category` param determines the category of quote used in the image. Optional `author` param gets the quote image of a given author.

{{baseUrl}}/quote/image/search

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/quote/image/search" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/image/search"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/image/search"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/search");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/search"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/quote/image/search HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/image/search")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/search"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/image/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/quote/image/search")
  .header("x-theysaidso-api-secret", "{{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}}/quote/image/search');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/image/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/search',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/search',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/image/search',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/search');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/image/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/search"]
                                                       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}}/quote/image/search" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/quote/image/search', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/search');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/search');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/search' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/search' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/image/search", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/search"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/search"

response <- VERB("GET", url, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/quote/image/search') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/search";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/image/search \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/image/search \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/image/search

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/search")! 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

{
  "success": {
    "total": 1
  },
  "contents": {
    "qimage": {
      "id": "75c3EoOmPVolqfB4KeUhXgeF",
      "quote_id": "5e0QH_0k5srOUN1Wdu9AgweF",
      "permalink": "https://theysaidso.com/i/75c3EoOmPVolqfB4KeUhXgeF",
      "download_uri": "https://theysaidso.com/i/image/75c3EoOmPVolqfB4KeUhXgeF"
    }
  },
  "copyright": "2019-22 https://theysaidso.com"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote image matching the query criteria not found"
    }
}

GET Lists background images in your private collection. (GET)

{{baseUrl}}/quote/image/font/list

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/font/list");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/quote/image/font/list" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/image/font/list"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/image/font/list"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/font/list");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/font/list"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/quote/image/font/list HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/image/font/list")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/font/list"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/image/font/list")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/quote/image/font/list")
  .header("x-theysaidso-api-secret", "{{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}}/quote/image/font/list');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/image/font/list',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/font/list';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/font/list',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/font/list")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/font/list',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/image/font/list',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/font/list');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/image/font/list',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/font/list';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/font/list"]
                                                       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}}/quote/image/font/list" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/font/list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/quote/image/font/list', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/font/list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/font/list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/font/list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/font/list' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/image/font/list", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/font/list"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/font/list"

response <- VERB("GET", url, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/font/list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/quote/image/font/list') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/font/list";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/image/font/list \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/image/font/list \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/image/font/list

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/font/list")! 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

{
  "success": {
    "total": 1
  },
  "contents": {
    "qimage": {
      "id": "75c3EoOmPVolqfB4KeUhXgeF",
      "quote_id": "5e0QH_0k5srOUN1Wdu9AgweF",
      "permalink": "https://theysaidso.com/i/75c3EoOmPVolqfB4KeUhXgeF",
      "download_uri": "https://theysaidso.com/i/image/75c3EoOmPVolqfB4KeUhXgeF"
    }
  },
  "copyright": "2019-22 https://theysaidso.com"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote image matching the query criteria not found"
    }
}

GET Lists background images in your private collection.

{{baseUrl}}/quote/image/background/list

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/background/list");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/quote/image/background/list" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/image/background/list"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/image/background/list"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/background/list");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/background/list"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/quote/image/background/list HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/image/background/list")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/background/list"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/image/background/list")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/quote/image/background/list")
  .header("x-theysaidso-api-secret", "{{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}}/quote/image/background/list');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/image/background/list',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/background/list';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/background/list',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/background/list")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/background/list',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/image/background/list',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/background/list');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/image/background/list',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/background/list';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/background/list"]
                                                       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}}/quote/image/background/list" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/background/list",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/quote/image/background/list', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/background/list');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/background/list');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/background/list' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/background/list' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/image/background/list", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/background/list"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/background/list"

response <- VERB("GET", url, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/background/list")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/quote/image/background/list') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/background/list";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/image/background/list \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/image/background/list \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/image/background/list

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/background/list")! 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

{
  "success": {
    "total": 1
  },
  "contents": {
    "qimage": {
      "id": "75c3EoOmPVolqfB4KeUhXgeF",
      "quote_id": "5e0QH_0k5srOUN1Wdu9AgweF",
      "permalink": "https://theysaidso.com/i/75c3EoOmPVolqfB4KeUhXgeF",
      "download_uri": "https://theysaidso.com/i/image/75c3EoOmPVolqfB4KeUhXgeF"
    }
  },
  "copyright": "2019-22 https://theysaidso.com"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote image matching the query criteria not found"
    }
}

POST Remove a tag from a given Font.

{{baseUrl}}/quote/image/font/tags/remove

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

tags

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/font/tags/remove?id=&tags=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/quote/image/font/tags/remove" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                                         :query-params {:id ""
                                                                                        :tags ""}})

require "http/client"

url = "{{baseUrl}}/quote/image/font/tags/remove?id=&tags="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/quote/image/font/tags/remove?id=&tags="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/font/tags/remove?id=&tags=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/font/tags/remove?id=&tags="

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/quote/image/font/tags/remove?id=&tags= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/image/font/tags/remove?id=&tags=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/font/tags/remove?id=&tags="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/image/font/tags/remove?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/quote/image/font/tags/remove?id=&tags=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/quote/image/font/tags/remove?id=&tags=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/image/font/tags/remove',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/font/tags/remove?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/font/tags/remove?id=&tags=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/font/tags/remove?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/font/tags/remove?id=&tags=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/image/font/tags/remove',
  qs: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/quote/image/font/tags/remove');

req.query({
  id: '',
  tags: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/image/font/tags/remove',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/font/tags/remove?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/font/tags/remove?id=&tags="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/image/font/tags/remove?id=&tags=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/font/tags/remove?id=&tags=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/quote/image/font/tags/remove?id=&tags=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/font/tags/remove');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'id' => '',
  'tags' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/font/tags/remove');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'id' => '',
  'tags' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/font/tags/remove?id=&tags=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/font/tags/remove?id=&tags=' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/quote/image/font/tags/remove?id=&tags=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/font/tags/remove"

querystring = {"id":"","tags":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/font/tags/remove"

queryString <- list(
  id = "",
  tags = ""
)

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/font/tags/remove?id=&tags=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/quote/image/font/tags/remove') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
  req.params['tags'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/font/tags/remove";

    let querystring = [
        ("id", ""),
        ("tags", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/quote/image/font/tags/remove?id=&tags=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/quote/image/font/tags/remove?id=&tags=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/image/font/tags/remove?id=&tags='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/font/tags/remove?id=&tags=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Font not found"
    }
}

POST Remove a tag from a given Image.

{{baseUrl}}/quote/image/background/tags/remove

HEADERS

X-TheySaidSo-Api-Secret

QUERY PARAMS

tags

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/background/tags/remove?id=&tags=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/quote/image/background/tags/remove" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}
                                                                               :query-params {:id ""
                                                                                              :tags ""}})

require "http/client"

url = "{{baseUrl}}/quote/image/background/tags/remove?id=&tags="
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{apiKey}}"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/quote/image/background/tags/remove?id=&tags="),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/background/tags/remove?id=&tags=");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/background/tags/remove?id=&tags="

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/quote/image/background/tags/remove?id=&tags= HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/quote/image/background/tags/remove?id=&tags=")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/background/tags/remove?id=&tags="))
    .header("x-theysaidso-api-secret", "{{apiKey}}")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/quote/image/background/tags/remove?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/quote/image/background/tags/remove?id=&tags=")
  .header("x-theysaidso-api-secret", "{{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('POST', '{{baseUrl}}/quote/image/background/tags/remove?id=&tags=');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/quote/image/background/tags/remove',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/background/tags/remove?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/background/tags/remove?id=&tags=',
  method: 'POST',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/background/tags/remove?id=&tags=")
  .post(null)
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/background/tags/remove?id=&tags=',
  headers: {
    'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/image/background/tags/remove',
  qs: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/quote/image/background/tags/remove');

req.query({
  id: '',
  tags: ''
});

req.headers({
  'x-theysaidso-api-secret': '{{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: 'POST',
  url: '{{baseUrl}}/quote/image/background/tags/remove',
  params: {id: '', tags: ''},
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/background/tags/remove?id=&tags=';
const options = {method: 'POST', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/background/tags/remove?id=&tags="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/quote/image/background/tags/remove?id=&tags=" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/background/tags/remove?id=&tags=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/quote/image/background/tags/remove?id=&tags=', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/background/tags/remove');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'id' => '',
  'tags' => ''
]);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/background/tags/remove');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'id' => '',
  'tags' => ''
]));

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/background/tags/remove?id=&tags=' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/background/tags/remove?id=&tags=' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("POST", "/baseUrl/quote/image/background/tags/remove?id=&tags=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/background/tags/remove"

querystring = {"id":"","tags":""}

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.post(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/background/tags/remove"

queryString <- list(
  id = "",
  tags = ""
)

response <- VERB("POST", url, query = queryString, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/background/tags/remove?id=&tags=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/quote/image/background/tags/remove') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
  req.params['id'] = ''
  req.params['tags'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/background/tags/remove";

    let querystring = [
        ("id", ""),
        ("tags", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/quote/image/background/tags/remove?id=&tags=' \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http POST '{{baseUrl}}/quote/image/background/tags/remove?id=&tags=' \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/quote/image/background/tags/remove?id=&tags='

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/background/tags/remove?id=&tags=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Image not found"
    }
}

GET Searches for a background image with a given tag.

{{baseUrl}}/quote/image/background/search

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/background/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/quote/image/background/search" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/image/background/search"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/image/background/search"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/background/search");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/background/search"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/quote/image/background/search HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/image/background/search")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/background/search"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/image/background/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/quote/image/background/search")
  .header("x-theysaidso-api-secret", "{{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}}/quote/image/background/search');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/image/background/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/background/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/background/search',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/background/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/background/search',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/image/background/search',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/background/search');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/image/background/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/background/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/background/search"]
                                                       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}}/quote/image/background/search" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/background/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/quote/image/background/search', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/background/search');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/background/search');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/background/search' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/background/search' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/image/background/search", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/background/search"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/background/search"

response <- VERB("GET", url, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/background/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/quote/image/background/search') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/background/search";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/image/background/search \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/image/background/search \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/image/background/search

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/background/search")! 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

{
  "success": {
    "total": 1
  },
  "contents": {
    "qimage": {
      "id": "75c3EoOmPVolqfB4KeUhXgeF",
      "quote_id": "5e0QH_0k5srOUN1Wdu9AgweF",
      "permalink": "https://theysaidso.com/i/75c3EoOmPVolqfB4KeUhXgeF",
      "download_uri": "https://theysaidso.com/i/image/75c3EoOmPVolqfB4KeUhXgeF"
    }
  },
  "copyright": "2019-22 https://theysaidso.com"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote image matching the query criteria not found"
    }
}

GET Searches for a font with a given tag.

{{baseUrl}}/quote/image/font/search

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/quote/image/font/search");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/quote/image/font/search" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/quote/image/font/search"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/quote/image/font/search"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/quote/image/font/search");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/quote/image/font/search"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/quote/image/font/search HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/quote/image/font/search")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/quote/image/font/search"))
    .header("x-theysaidso-api-secret", "{{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}}/quote/image/font/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/quote/image/font/search")
  .header("x-theysaidso-api-secret", "{{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}}/quote/image/font/search');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/quote/image/font/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/quote/image/font/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/font/search',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/quote/image/font/search")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/quote/image/font/search',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/quote/image/font/search',
  headers: {'x-theysaidso-api-secret': '{{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}}/quote/image/font/search');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/quote/image/font/search',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/quote/image/font/search';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/quote/image/font/search"]
                                                       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}}/quote/image/font/search" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/quote/image/font/search",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/quote/image/font/search', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/quote/image/font/search');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/quote/image/font/search');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/quote/image/font/search' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/quote/image/font/search' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/quote/image/font/search", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/quote/image/font/search"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/quote/image/font/search"

response <- VERB("GET", url, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/quote/image/font/search")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/quote/image/font/search') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/quote/image/font/search";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/quote/image/font/search \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/quote/image/font/search \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/quote/image/font/search

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/quote/image/font/search")! 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

{
  "success": {
    "total": 1
  },
  "contents": {
    "qimage": {
      "id": "75c3EoOmPVolqfB4KeUhXgeF",
      "quote_id": "5e0QH_0k5srOUN1Wdu9AgweF",
      "permalink": "https://theysaidso.com/i/75c3EoOmPVolqfB4KeUhXgeF",
      "download_uri": "https://theysaidso.com/i/image/75c3EoOmPVolqfB4KeUhXgeF"
    }
  },
  "copyright": "2019-22 https://theysaidso.com"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 401,
        "message": "Unauthorized"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "error": {
        "code": 404,
        "message": "Not Found: Quote image matching the query criteria not found"
    }
}

GET Gets `Quote of the Day`. Optional `category` param determines the category of returned quote of the day

{{baseUrl}}/qod

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/qod");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/qod" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/qod"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/qod"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qod");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/qod"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/qod HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/qod")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qod"))
    .header("x-theysaidso-api-secret", "{{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}}/qod")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/qod")
  .header("x-theysaidso-api-secret", "{{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}}/qod');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/qod',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/qod';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/qod',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qod")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qod',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/qod',
  headers: {'x-theysaidso-api-secret': '{{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}}/qod');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/qod',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/qod';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/qod"]
                                                       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}}/qod" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/qod",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/qod', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/qod');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/qod');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qod' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qod' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/qod", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/qod"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/qod"

response <- VERB("GET", url, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qod")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/qod') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/qod";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/qod \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/qod \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/qod

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qod")! 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

{
    "success": {
        "total": 1
    },
    "contents": {
        "quotes": [
            {
                "quote": "Do not worry if you have built your castles in the air. They are where they should be. Now put the foundations under them.",
                "length": "122",
                "author": "Henry David Thoreau",
                "tags": [
                    "dreams",
                    "inspire",
                    "worry"
                ],
                "category": "inspire",
                "date": "2016-11-21",
                "title": "Inspiring Quote of the day",
                "background": "https://theysaidso.com/img/bgs/man_on_the_mountain.jpg",
                "id": "mYpH8syTM8rf8KFORoAJmQeF"
            }
        ]
    }
}

RESPONSE HEADERS

Content-Type

application/xml

RESPONSE BODY xml

 
  
    1
  
  
    
      Sometimes you climb out of bed in the morning and you think, I'm not going to make it, but you laugh inside — remembering all the times you've felt that way.
      164
      Charles Bukowski
      depression
      inspire
      tso-life
      inspire
      2016-11-23
      Inspiring Quote of the day
      https://theysaidso.com/img/bgs/man_on_the_mountain.jpg
      k7rTMtmveYHUN2ImwxNhhAeF

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": {
    "code": 400,
    "message": "Bad Request: QOD category not supported for this category and language combination"
  }
}

GET Gets a list of `Quote of the Day` Categories.

{{baseUrl}}/qod/categories

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/qod/categories");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/qod/categories" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/qod/categories"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/qod/categories"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qod/categories");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/qod/categories"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/qod/categories HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/qod/categories")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qod/categories"))
    .header("x-theysaidso-api-secret", "{{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}}/qod/categories")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/qod/categories")
  .header("x-theysaidso-api-secret", "{{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}}/qod/categories');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/qod/categories',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/qod/categories';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/qod/categories',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qod/categories")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qod/categories',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/qod/categories',
  headers: {'x-theysaidso-api-secret': '{{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}}/qod/categories');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/qod/categories',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/qod/categories';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/qod/categories"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/qod/categories" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/qod/categories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/qod/categories', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/qod/categories');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/qod/categories');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qod/categories' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qod/categories' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/qod/categories", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/qod/categories"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/qod/categories"

response <- VERB("GET", url, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qod/categories")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/qod/categories') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/qod/categories";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/qod/categories \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/qod/categories \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/qod/categories

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qod/categories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
    "success": {
        "total": 8
    },
    "contents": {
        "categories": {
            "inspire": "Inspiring Quote of the day",
            "management": "Management Quote of the day",
            "sports": "Sports Quote of the day",
            "life": "Quote of the day about life",
            "funny": "Funny Quote of the day",
            "love": "Quote of the day about Love",
            "art": "Art quote of the day ",
            "students": "Quote of the day for students"
        },
        "copyright": "2013-15 http://theysaidso.com"
    }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": {
    "code": 400,
    "message": "No QOD categories defined for this language."
  }
}

GET Gets a list of supported languages for `Quote of the Day`.

{{baseUrl}}/qod/languages

HEADERS

X-TheySaidSo-Api-Secret

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/qod/languages");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-theysaidso-api-secret: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/qod/languages" {:headers {:x-theysaidso-api-secret "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/qod/languages"
headers = HTTP::Headers{
  "x-theysaidso-api-secret" => "{{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}}/qod/languages"),
    Headers =
    {
        { "x-theysaidso-api-secret", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/qod/languages");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-theysaidso-api-secret", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/qod/languages"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("x-theysaidso-api-secret", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/qod/languages HTTP/1.1
X-Theysaidso-Api-Secret: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/qod/languages")
  .setHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/qod/languages"))
    .header("x-theysaidso-api-secret", "{{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}}/qod/languages")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/qod/languages")
  .header("x-theysaidso-api-secret", "{{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}}/qod/languages');
xhr.setRequestHeader('x-theysaidso-api-secret', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/qod/languages',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/qod/languages';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{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}}/qod/languages',
  method: 'GET',
  headers: {
    'x-theysaidso-api-secret': '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/qod/languages")
  .get()
  .addHeader("x-theysaidso-api-secret", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/qod/languages',
  headers: {
    'x-theysaidso-api-secret': '{{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}}/qod/languages',
  headers: {'x-theysaidso-api-secret': '{{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}}/qod/languages');

req.headers({
  'x-theysaidso-api-secret': '{{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}}/qod/languages',
  headers: {'x-theysaidso-api-secret': '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/qod/languages';
const options = {method: 'GET', headers: {'x-theysaidso-api-secret': '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-theysaidso-api-secret": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/qod/languages"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/qod/languages" in
let headers = Header.add (Header.init ()) "x-theysaidso-api-secret" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/qod/languages",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "x-theysaidso-api-secret: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/qod/languages', [
  'headers' => [
    'x-theysaidso-api-secret' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/qod/languages');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/qod/languages');
$request->setRequestMethod('GET');
$request->setHeaders([
  'x-theysaidso-api-secret' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/qod/languages' -Method GET -Headers $headers

$headers=@{}
$headers.Add("x-theysaidso-api-secret", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/qod/languages' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'x-theysaidso-api-secret': "{{apiKey}}" }

conn.request("GET", "/baseUrl/qod/languages", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/qod/languages"

headers = {"x-theysaidso-api-secret": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/qod/languages"

response <- VERB("GET", url, add_headers('x-theysaidso-api-secret' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/qod/languages")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["x-theysaidso-api-secret"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/qod/languages') do |req|
  req.headers['x-theysaidso-api-secret'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/qod/languages";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-theysaidso-api-secret", "{{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}}/qod/languages \
  --header 'x-theysaidso-api-secret: {{apiKey}}'

http GET {{baseUrl}}/qod/languages \
  x-theysaidso-api-secret:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'x-theysaidso-api-secret: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/qod/languages

import Foundation

let headers = ["x-theysaidso-api-secret": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/qod/languages")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": {
    "total": 2
  },
  "contents": {
    "languages": [
      "en",
      "fr",
      "ta"
    ]
  },
  "baseurl": "https://theysaidso.com",
  "copyright": "2019-22 https://theysaidso.com"
}