CIS Automotive API
POST
Generate a Sub User Key that can be used by your users to make API calls in frontend applications.
{{baseUrl}}/makeSubUserKey
QUERY PARAMS
apiID
apiKey
BODY json
{
"endPoints": []
}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/makeSubUserKey?apiID=&apiKey=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n \"endPoints\": []\n}");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/makeSubUserKey" {:query-params {:apiID ""
:apiKey ""}
:content-type :json
:form-params {:endPoints []}})require "http/client"
url = "{{baseUrl}}/makeSubUserKey?apiID=&apiKey="
headers = HTTP::Headers{
"content-type" => "application/json"
}
reqBody = "{\n \"endPoints\": []\n}"
response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/makeSubUserKey?apiID=&apiKey="),
Content = new StringContent("{\n \"endPoints\": []\n}")
{
Headers =
{
ContentType = new MediaTypeHeaderValue("application/json")
}
}
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/makeSubUserKey?apiID=&apiKey=");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n \"endPoints\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);package main
import (
"fmt"
"strings"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/makeSubUserKey?apiID=&apiKey="
payload := strings.NewReader("{\n \"endPoints\": []\n}")
req, _ := http.NewRequest("POST", url, payload)
req.Header.Add("content-type", "application/json")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/makeSubUserKey?apiID=&apiKey= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 21
{
"endPoints": []
}AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/makeSubUserKey?apiID=&apiKey=")
.setHeader("content-type", "application/json")
.setBody("{\n \"endPoints\": []\n}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/makeSubUserKey?apiID=&apiKey="))
.header("content-type", "application/json")
.method("POST", HttpRequest.BodyPublishers.ofString("{\n \"endPoints\": []\n}"))
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n \"endPoints\": []\n}");
Request request = new Request.Builder()
.url("{{baseUrl}}/makeSubUserKey?apiID=&apiKey=")
.post(body)
.addHeader("content-type", "application/json")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/makeSubUserKey?apiID=&apiKey=")
.header("content-type", "application/json")
.body("{\n \"endPoints\": []\n}")
.asString(); const data = JSON.stringify({
endPoints: []
});
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/makeSubUserKey?apiID=&apiKey=');
xhr.setRequestHeader('content-type', 'application/json');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/makeSubUserKey',
params: {apiID: '', apiKey: ''},
headers: {'content-type': 'application/json'},
data: {endPoints: []}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/makeSubUserKey?apiID=&apiKey=';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"endPoints":[]}'
};
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}}/makeSubUserKey?apiID=&apiKey=',
method: 'POST',
headers: {
'content-type': 'application/json'
},
processData: false,
data: '{\n "endPoints": []\n}'
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n \"endPoints\": []\n}")
val request = Request.Builder()
.url("{{baseUrl}}/makeSubUserKey?apiID=&apiKey=")
.post(body)
.addHeader("content-type", "application/json")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/makeSubUserKey?apiID=&apiKey=',
headers: {
'content-type': 'application/json'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.write(JSON.stringify({endPoints: []}));
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/makeSubUserKey',
qs: {apiID: '', apiKey: ''},
headers: {'content-type': 'application/json'},
body: {endPoints: []},
json: true
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/makeSubUserKey');
req.query({
apiID: '',
apiKey: ''
});
req.headers({
'content-type': 'application/json'
});
req.type('json');
req.send({
endPoints: []
});
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}}/makeSubUserKey',
params: {apiID: '', apiKey: ''},
headers: {'content-type': 'application/json'},
data: {endPoints: []}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/makeSubUserKey?apiID=&apiKey=';
const options = {
method: 'POST',
headers: {'content-type': 'application/json'},
body: '{"endPoints":[]}'
};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"endPoints": @[ ] };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/makeSubUserKey?apiID=&apiKey="]
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}}/makeSubUserKey?apiID=&apiKey=" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n \"endPoints\": []\n}" in
Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/makeSubUserKey?apiID=&apiKey=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_POSTFIELDS => json_encode([
'endPoints' => [
]
]),
CURLOPT_HTTPHEADER => [
"content-type: application/json"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/makeSubUserKey?apiID=&apiKey=', [
'body' => '{
"endPoints": []
}',
'headers' => [
'content-type' => 'application/json',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/makeSubUserKey');
$request->setMethod(HTTP_METH_POST);
$request->setQueryData([
'apiID' => '',
'apiKey' => ''
]);
$request->setHeaders([
'content-type' => 'application/json'
]);
$request->setContentType('application/json');
$request->setBody(json_encode([
'endPoints' => [
]
]));
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}append(json_encode([
'endPoints' => [
]
]));
$request->setRequestUrl('{{baseUrl}}/makeSubUserKey');
$request->setRequestMethod('POST');
$request->setBody($body);
$request->setQuery(new http\QueryString([
'apiID' => '',
'apiKey' => ''
]));
$request->setHeaders([
'content-type' => 'application/json'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/makeSubUserKey?apiID=&apiKey=' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"endPoints": []
}'$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/makeSubUserKey?apiID=&apiKey=' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
"endPoints": []
}'import http.client
conn = http.client.HTTPSConnection("example.com")
payload = "{\n \"endPoints\": []\n}"
headers = { 'content-type': "application/json" }
conn.request("POST", "/baseUrl/makeSubUserKey?apiID=&apiKey=", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/makeSubUserKey"
querystring = {"apiID":"","apiKey":""}
payload = { "endPoints": [] }
headers = {"content-type": "application/json"}
response = requests.post(url, json=payload, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/makeSubUserKey"
queryString <- list(
apiID = "",
apiKey = ""
)
payload <- "{\n \"endPoints\": []\n}"
encode <- "json"
response <- VERB("POST", url, body = payload, query = queryString, content_type("application/json"), encode = encode)
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/makeSubUserKey?apiID=&apiKey=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n \"endPoints\": []\n}"
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
headers: {'Content-Type' => 'application/json'}
)
response = conn.post('/baseUrl/makeSubUserKey') do |req|
req.params['apiID'] = ''
req.params['apiKey'] = ''
req.body = "{\n \"endPoints\": []\n}"
end
puts response.status
puts response.bodyuse serde_json::json;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/makeSubUserKey";
let querystring = [
("apiID", ""),
("apiKey", ""),
];
let payload = json!({"endPoints": ()});
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("content-type", "application/json".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.query(&querystring)
.headers(headers)
.json(&payload)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/makeSubUserKey?apiID=&apiKey=' \
--header 'content-type: application/json' \
--data '{
"endPoints": []
}'echo '{
"endPoints": []
}' | \
http POST '{{baseUrl}}/makeSubUserKey?apiID=&apiKey=' \
content-type:application/jsonwget --quiet \
--method POST \
--header 'content-type: application/json' \
--body-data '{\n "endPoints": []\n}' \
--output-document \
- '{{baseUrl}}/makeSubUserKey?apiID=&apiKey='import Foundation
let headers = ["content-type": "application/json"]
let parameters = ["endPoints": []] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/makeSubUserKey?apiID=&apiKey=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Get a JWT from your API credentials (POST)
{{baseUrl}}/getToken
QUERY PARAMS
apiID
apiKey
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getToken?apiID=&apiKey=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/getToken" {:query-params {:apiID ""
:apiKey ""}})require "http/client"
url = "{{baseUrl}}/getToken?apiID=&apiKey="
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/getToken?apiID=&apiKey="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getToken?apiID=&apiKey=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getToken?apiID=&apiKey="
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/getToken?apiID=&apiKey= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/getToken?apiID=&apiKey=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getToken?apiID=&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}}/getToken?apiID=&apiKey=")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/getToken?apiID=&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}}/getToken?apiID=&apiKey=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/getToken',
params: {apiID: '', apiKey: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getToken?apiID=&apiKey=';
const options = {method: 'POST'};
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}}/getToken?apiID=&apiKey=',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getToken?apiID=&apiKey=")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/getToken?apiID=&apiKey=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/getToken',
qs: {apiID: '', 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}}/getToken');
req.query({
apiID: '',
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}}/getToken',
params: {apiID: '', apiKey: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getToken?apiID=&apiKey=';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getToken?apiID=&apiKey="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
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}}/getToken?apiID=&apiKey=" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getToken?apiID=&apiKey=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/getToken?apiID=&apiKey=');
echo $response->getBody();setUrl('{{baseUrl}}/getToken');
$request->setMethod(HTTP_METH_POST);
$request->setQueryData([
'apiID' => '',
'apiKey' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getToken');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
'apiID' => '',
'apiKey' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getToken?apiID=&apiKey=' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/getToken?apiID=&apiKey=' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/getToken?apiID=&apiKey=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getToken"
querystring = {"apiID":"","apiKey":""}
response = requests.post(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getToken"
queryString <- list(
apiID = "",
apiKey = ""
)
response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getToken?apiID=&apiKey=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/getToken') do |req|
req.params['apiID'] = ''
req.params['apiKey'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getToken";
let querystring = [
("apiID", ""),
("apiKey", ""),
];
let client = reqwest::Client::new();
let response = client.post(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/getToken?apiID=&apiKey='http POST '{{baseUrl}}/getToken?apiID=&apiKey='wget --quiet \
--method POST \
--output-document \
- '{{baseUrl}}/getToken?apiID=&apiKey='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getToken?apiID=&apiKey=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get a JWT from your API credentials
{{baseUrl}}/getToken
QUERY PARAMS
apiID
apiKey
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getToken?apiID=&apiKey=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getToken" {:query-params {:apiID ""
:apiKey ""}})require "http/client"
url = "{{baseUrl}}/getToken?apiID=&apiKey="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getToken?apiID=&apiKey="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getToken?apiID=&apiKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getToken?apiID=&apiKey="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getToken?apiID=&apiKey= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getToken?apiID=&apiKey=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getToken?apiID=&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}}/getToken?apiID=&apiKey=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getToken?apiID=&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}}/getToken?apiID=&apiKey=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getToken',
params: {apiID: '', apiKey: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getToken?apiID=&apiKey=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getToken?apiID=&apiKey=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getToken?apiID=&apiKey=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getToken?apiID=&apiKey=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/getToken',
qs: {apiID: '', 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}}/getToken');
req.query({
apiID: '',
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}}/getToken',
params: {apiID: '', apiKey: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getToken?apiID=&apiKey=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getToken?apiID=&apiKey="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getToken?apiID=&apiKey=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getToken?apiID=&apiKey=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getToken?apiID=&apiKey=');
echo $response->getBody();setUrl('{{baseUrl}}/getToken');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'apiID' => '',
'apiKey' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getToken');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'apiID' => '',
'apiKey' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getToken?apiID=&apiKey=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getToken?apiID=&apiKey=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getToken?apiID=&apiKey=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getToken"
querystring = {"apiID":"","apiKey":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getToken"
queryString <- list(
apiID = "",
apiKey = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getToken?apiID=&apiKey=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getToken') do |req|
req.params['apiID'] = ''
req.params['apiKey'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getToken";
let querystring = [
("apiID", ""),
("apiKey", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getToken?apiID=&apiKey='http GET '{{baseUrl}}/getToken?apiID=&apiKey='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getToken?apiID=&apiKey='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getToken?apiID=&apiKey=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get all Sub User Keys associated with your account.
{{baseUrl}}/getSubUserKeys
QUERY PARAMS
apiID
apiKey
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getSubUserKeys?apiID=&apiKey=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getSubUserKeys" {:query-params {:apiID ""
:apiKey ""}})require "http/client"
url = "{{baseUrl}}/getSubUserKeys?apiID=&apiKey="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getSubUserKeys?apiID=&apiKey="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getSubUserKeys?apiID=&apiKey=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getSubUserKeys?apiID=&apiKey="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getSubUserKeys?apiID=&apiKey= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getSubUserKeys?apiID=&apiKey=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getSubUserKeys?apiID=&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}}/getSubUserKeys?apiID=&apiKey=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getSubUserKeys?apiID=&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}}/getSubUserKeys?apiID=&apiKey=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getSubUserKeys',
params: {apiID: '', apiKey: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getSubUserKeys?apiID=&apiKey=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getSubUserKeys?apiID=&apiKey=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getSubUserKeys?apiID=&apiKey=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getSubUserKeys?apiID=&apiKey=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/getSubUserKeys',
qs: {apiID: '', 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}}/getSubUserKeys');
req.query({
apiID: '',
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}}/getSubUserKeys',
params: {apiID: '', apiKey: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getSubUserKeys?apiID=&apiKey=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getSubUserKeys?apiID=&apiKey="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getSubUserKeys?apiID=&apiKey=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getSubUserKeys?apiID=&apiKey=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getSubUserKeys?apiID=&apiKey=');
echo $response->getBody();setUrl('{{baseUrl}}/getSubUserKeys');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'apiID' => '',
'apiKey' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getSubUserKeys');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'apiID' => '',
'apiKey' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getSubUserKeys?apiID=&apiKey=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getSubUserKeys?apiID=&apiKey=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getSubUserKeys?apiID=&apiKey=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getSubUserKeys"
querystring = {"apiID":"","apiKey":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getSubUserKeys"
queryString <- list(
apiID = "",
apiKey = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getSubUserKeys?apiID=&apiKey=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getSubUserKeys') do |req|
req.params['apiID'] = ''
req.params['apiKey'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getSubUserKeys";
let querystring = [
("apiID", ""),
("apiKey", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getSubUserKeys?apiID=&apiKey='http GET '{{baseUrl}}/getSubUserKeys?apiID=&apiKey='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getSubUserKeys?apiID=&apiKey='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getSubUserKeys?apiID=&apiKey=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Revoke a Sub User Key associated with your account.
{{baseUrl}}/revokeSubUserKey
QUERY PARAMS
apiID
apiKey
subUserKeyUUID
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/revokeSubUserKey" {:query-params {:apiID ""
:apiKey ""
:subUserKeyUUID ""}})require "http/client"
url = "{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID="
response = HTTP::Client.put url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID="
req, _ := http.NewRequest("PUT", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID="))
.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}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=")
.put(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=")
.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}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/revokeSubUserKey',
params: {apiID: '', apiKey: '', subUserKeyUUID: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=';
const options = {method: 'PUT'};
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}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=',
method: 'PUT',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=")
.put(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/revokeSubUserKey',
qs: {apiID: '', apiKey: '', subUserKeyUUID: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/revokeSubUserKey');
req.query({
apiID: '',
apiKey: '',
subUserKeyUUID: ''
});
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}}/revokeSubUserKey',
params: {apiID: '', apiKey: '', subUserKeyUUID: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=';
const options = {method: 'PUT'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
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}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=" in
Client.call `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=');
echo $response->getBody();setUrl('{{baseUrl}}/revokeSubUserKey');
$request->setMethod(HTTP_METH_PUT);
$request->setQueryData([
'apiID' => '',
'apiKey' => '',
'subUserKeyUUID' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/revokeSubUserKey');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
'apiID' => '',
'apiKey' => '',
'subUserKeyUUID' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=' -Method PUT $response = Invoke-RestMethod -Uri '{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=' -Method PUT import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("PUT", "/baseUrl/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/revokeSubUserKey"
querystring = {"apiID":"","apiKey":"","subUserKeyUUID":""}
response = requests.put(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/revokeSubUserKey"
queryString <- list(
apiID = "",
apiKey = "",
subUserKeyUUID = ""
)
response <- VERB("PUT", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/revokeSubUserKey') do |req|
req.params['apiID'] = ''
req.params['apiKey'] = ''
req.params['subUserKeyUUID'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/revokeSubUserKey";
let querystring = [
("apiID", ""),
("apiKey", ""),
("subUserKeyUUID", ""),
];
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url '{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID='http PUT '{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID='wget --quiet \
--method PUT \
--output-document \
- '{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/revokeSubUserKey?apiID=&apiKey=&subUserKeyUUID=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getDealersByID?jwt=&dealerID=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getDealersByID" {:query-params {:jwt ""
:dealerID ""}})require "http/client"
url = "{{baseUrl}}/getDealersByID?jwt=&dealerID="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getDealersByID?jwt=&dealerID="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getDealersByID?jwt=&dealerID=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getDealersByID?jwt=&dealerID="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getDealersByID?jwt=&dealerID= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getDealersByID?jwt=&dealerID=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getDealersByID?jwt=&dealerID="))
.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}}/getDealersByID?jwt=&dealerID=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getDealersByID?jwt=&dealerID=")
.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}}/getDealersByID?jwt=&dealerID=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getDealersByID',
params: {jwt: '', dealerID: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getDealersByID?jwt=&dealerID=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getDealersByID?jwt=&dealerID=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getDealersByID?jwt=&dealerID=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getDealersByID?jwt=&dealerID=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/getDealersByID',
qs: {jwt: '', dealerID: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/getDealersByID');
req.query({
jwt: '',
dealerID: ''
});
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}}/getDealersByID',
params: {jwt: '', dealerID: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getDealersByID?jwt=&dealerID=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getDealersByID?jwt=&dealerID="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getDealersByID?jwt=&dealerID=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getDealersByID?jwt=&dealerID=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getDealersByID?jwt=&dealerID=');
echo $response->getBody();setUrl('{{baseUrl}}/getDealersByID');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'dealerID' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getDealersByID');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'dealerID' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getDealersByID?jwt=&dealerID=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getDealersByID?jwt=&dealerID=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getDealersByID?jwt=&dealerID=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getDealersByID"
querystring = {"jwt":"","dealerID":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getDealersByID"
queryString <- list(
jwt = "",
dealerID = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getDealersByID?jwt=&dealerID=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getDealersByID') do |req|
req.params['jwt'] = ''
req.params['dealerID'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getDealersByID";
let querystring = [
("jwt", ""),
("dealerID", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getDealersByID?jwt=&dealerID='http GET '{{baseUrl}}/getDealersByID?jwt=&dealerID='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getDealersByID?jwt=&dealerID='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getDealersByID?jwt=&dealerID=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getDealersByRegion?jwt=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getDealersByRegion" {:query-params {:jwt ""}})require "http/client"
url = "{{baseUrl}}/getDealersByRegion?jwt="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getDealersByRegion?jwt="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getDealersByRegion?jwt=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getDealersByRegion?jwt="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getDealersByRegion?jwt= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getDealersByRegion?jwt=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getDealersByRegion?jwt="))
.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}}/getDealersByRegion?jwt=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getDealersByRegion?jwt=")
.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}}/getDealersByRegion?jwt=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getDealersByRegion',
params: {jwt: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getDealersByRegion?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getDealersByRegion?jwt=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getDealersByRegion?jwt=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getDealersByRegion?jwt=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/getDealersByRegion',
qs: {jwt: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/getDealersByRegion');
req.query({
jwt: ''
});
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}}/getDealersByRegion',
params: {jwt: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getDealersByRegion?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getDealersByRegion?jwt="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getDealersByRegion?jwt=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getDealersByRegion?jwt=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getDealersByRegion?jwt=');
echo $response->getBody();setUrl('{{baseUrl}}/getDealersByRegion');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getDealersByRegion');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getDealersByRegion?jwt=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getDealersByRegion?jwt=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getDealersByRegion?jwt=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getDealersByRegion"
querystring = {"jwt":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getDealersByRegion"
queryString <- list(jwt = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getDealersByRegion?jwt=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getDealersByRegion') do |req|
req.params['jwt'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getDealersByRegion";
let querystring = [
("jwt", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getDealersByRegion?jwt='http GET '{{baseUrl}}/getDealersByRegion?jwt='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getDealersByRegion?jwt='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getDealersByRegion?jwt=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getDealers?jwt=&zipCode=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getDealers" {:query-params {:jwt ""
:zipCode ""}})require "http/client"
url = "{{baseUrl}}/getDealers?jwt=&zipCode="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getDealers?jwt=&zipCode="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getDealers?jwt=&zipCode=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getDealers?jwt=&zipCode="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getDealers?jwt=&zipCode= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getDealers?jwt=&zipCode=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getDealers?jwt=&zipCode="))
.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}}/getDealers?jwt=&zipCode=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getDealers?jwt=&zipCode=")
.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}}/getDealers?jwt=&zipCode=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getDealers',
params: {jwt: '', zipCode: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getDealers?jwt=&zipCode=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getDealers?jwt=&zipCode=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getDealers?jwt=&zipCode=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getDealers?jwt=&zipCode=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/getDealers',
qs: {jwt: '', zipCode: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/getDealers');
req.query({
jwt: '',
zipCode: ''
});
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}}/getDealers',
params: {jwt: '', zipCode: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getDealers?jwt=&zipCode=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getDealers?jwt=&zipCode="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getDealers?jwt=&zipCode=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getDealers?jwt=&zipCode=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getDealers?jwt=&zipCode=');
echo $response->getBody();setUrl('{{baseUrl}}/getDealers');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'zipCode' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getDealers');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'zipCode' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getDealers?jwt=&zipCode=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getDealers?jwt=&zipCode=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getDealers?jwt=&zipCode=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getDealers"
querystring = {"jwt":"","zipCode":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getDealers"
queryString <- list(
jwt = "",
zipCode = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getDealers?jwt=&zipCode=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getDealers') do |req|
req.params['jwt'] = ''
req.params['zipCode'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getDealers";
let querystring = [
("jwt", ""),
("zipCode", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getDealers?jwt=&zipCode='http GET '{{baseUrl}}/getDealers?jwt=&zipCode='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getDealers?jwt=&zipCode='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getDealers?jwt=&zipCode=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Histogram of sales price of new vehicles by model
{{baseUrl}}/salePriceHistogram
QUERY PARAMS
jwt
modelName
brandName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/salePriceHistogram" {:query-params {:jwt ""
:modelName ""
:brandName ""}})require "http/client"
url = "{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/salePriceHistogram?jwt=&modelName=&brandName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName="))
.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}}/salePriceHistogram?jwt=&modelName=&brandName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=")
.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}}/salePriceHistogram?jwt=&modelName=&brandName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/salePriceHistogram',
params: {jwt: '', modelName: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/salePriceHistogram?jwt=&modelName=&brandName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/salePriceHistogram',
qs: {jwt: '', modelName: '', brandName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/salePriceHistogram');
req.query({
jwt: '',
modelName: '',
brandName: ''
});
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}}/salePriceHistogram',
params: {jwt: '', modelName: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=');
echo $response->getBody();setUrl('{{baseUrl}}/salePriceHistogram');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'modelName' => '',
'brandName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/salePriceHistogram');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'modelName' => '',
'brandName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/salePriceHistogram?jwt=&modelName=&brandName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/salePriceHistogram"
querystring = {"jwt":"","modelName":"","brandName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/salePriceHistogram"
queryString <- list(
jwt = "",
modelName = "",
brandName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/salePriceHistogram') do |req|
req.params['jwt'] = ''
req.params['modelName'] = ''
req.params['brandName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/salePriceHistogram";
let querystring = [
("jwt", ""),
("modelName", ""),
("brandName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName='http GET '{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/salePriceHistogram?jwt=&modelName=&brandName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Stats on ask price of new vehicles
{{baseUrl}}/listPrice
QUERY PARAMS
jwt
brandName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listPrice?jwt=&brandName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/listPrice" {:query-params {:jwt ""
:brandName ""}})require "http/client"
url = "{{baseUrl}}/listPrice?jwt=&brandName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/listPrice?jwt=&brandName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/listPrice?jwt=&brandName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/listPrice?jwt=&brandName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/listPrice?jwt=&brandName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listPrice?jwt=&brandName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/listPrice?jwt=&brandName="))
.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}}/listPrice?jwt=&brandName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/listPrice?jwt=&brandName=")
.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}}/listPrice?jwt=&brandName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/listPrice',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/listPrice?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/listPrice?jwt=&brandName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/listPrice?jwt=&brandName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/listPrice?jwt=&brandName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/listPrice',
qs: {jwt: '', brandName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/listPrice');
req.query({
jwt: '',
brandName: ''
});
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}}/listPrice',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/listPrice?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listPrice?jwt=&brandName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/listPrice?jwt=&brandName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/listPrice?jwt=&brandName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/listPrice?jwt=&brandName=');
echo $response->getBody();setUrl('{{baseUrl}}/listPrice');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'brandName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/listPrice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'brandName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/listPrice?jwt=&brandName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/listPrice?jwt=&brandName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/listPrice?jwt=&brandName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/listPrice"
querystring = {"jwt":"","brandName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/listPrice"
queryString <- list(
jwt = "",
brandName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/listPrice?jwt=&brandName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/listPrice') do |req|
req.params['jwt'] = ''
req.params['brandName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/listPrice";
let querystring = [
("jwt", ""),
("brandName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/listPrice?jwt=&brandName='http GET '{{baseUrl}}/listPrice?jwt=&brandName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/listPrice?jwt=&brandName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listPrice?jwt=&brandName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Stats on sale price of new vehicles
{{baseUrl}}/salePrice
QUERY PARAMS
jwt
brandName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/salePrice?jwt=&brandName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/salePrice" {:query-params {:jwt ""
:brandName ""}})require "http/client"
url = "{{baseUrl}}/salePrice?jwt=&brandName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/salePrice?jwt=&brandName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/salePrice?jwt=&brandName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/salePrice?jwt=&brandName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/salePrice?jwt=&brandName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/salePrice?jwt=&brandName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/salePrice?jwt=&brandName="))
.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}}/salePrice?jwt=&brandName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/salePrice?jwt=&brandName=")
.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}}/salePrice?jwt=&brandName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/salePrice',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/salePrice?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/salePrice?jwt=&brandName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/salePrice?jwt=&brandName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/salePrice?jwt=&brandName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/salePrice',
qs: {jwt: '', brandName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/salePrice');
req.query({
jwt: '',
brandName: ''
});
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}}/salePrice',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/salePrice?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/salePrice?jwt=&brandName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/salePrice?jwt=&brandName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/salePrice?jwt=&brandName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/salePrice?jwt=&brandName=');
echo $response->getBody();setUrl('{{baseUrl}}/salePrice');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'brandName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/salePrice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'brandName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/salePrice?jwt=&brandName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/salePrice?jwt=&brandName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/salePrice?jwt=&brandName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/salePrice"
querystring = {"jwt":"","brandName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/salePrice"
queryString <- list(
jwt = "",
brandName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/salePrice?jwt=&brandName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/salePrice') do |req|
req.params['jwt'] = ''
req.params['brandName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/salePrice";
let querystring = [
("jwt", ""),
("brandName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/salePrice?jwt=&brandName='http GET '{{baseUrl}}/salePrice?jwt=&brandName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/salePrice?jwt=&brandName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/salePrice?jwt=&brandName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Brand sales by region and Day
{{baseUrl}}/regionDailySales
QUERY PARAMS
jwt
brandName
regionName
day
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/regionDailySales" {:query-params {:jwt ""
:brandName ""
:regionName ""
:day ""}})require "http/client"
url = "{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/regionDailySales?jwt=&brandName=®ionName=&day= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day="))
.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}}/regionDailySales?jwt=&brandName=®ionName=&day=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=")
.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}}/regionDailySales?jwt=&brandName=®ionName=&day=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/regionDailySales',
params: {jwt: '', brandName: '', regionName: '', day: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/regionDailySales?jwt=&brandName=®ionName=&day=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/regionDailySales',
qs: {jwt: '', brandName: '', regionName: '', day: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/regionDailySales');
req.query({
jwt: '',
brandName: '',
regionName: '',
day: ''
});
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}}/regionDailySales',
params: {jwt: '', brandName: '', regionName: '', day: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=');
echo $response->getBody();setUrl('{{baseUrl}}/regionDailySales');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'brandName' => '',
'regionName' => '',
'day' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/regionDailySales');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'brandName' => '',
'regionName' => '',
'day' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/regionDailySales?jwt=&brandName=®ionName=&day=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/regionDailySales"
querystring = {"jwt":"","brandName":"","regionName":"","day":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/regionDailySales"
queryString <- list(
jwt = "",
brandName = "",
regionName = "",
day = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/regionDailySales') do |req|
req.params['jwt'] = ''
req.params['brandName'] = ''
req.params['regionName'] = ''
req.params['day'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/regionDailySales";
let querystring = [
("jwt", ""),
("brandName", ""),
("regionName", ""),
("day", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day='http GET '{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/regionDailySales?jwt=&brandName=®ionName=&day=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getRegionBrandMarketShare" {:query-params {:jwt ""
:brandName ""}})require "http/client"
url = "{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getRegionBrandMarketShare?jwt=&brandName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName="))
.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}}/getRegionBrandMarketShare?jwt=&brandName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=")
.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}}/getRegionBrandMarketShare?jwt=&brandName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getRegionBrandMarketShare',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getRegionBrandMarketShare?jwt=&brandName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/getRegionBrandMarketShare',
qs: {jwt: '', brandName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/getRegionBrandMarketShare');
req.query({
jwt: '',
brandName: ''
});
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}}/getRegionBrandMarketShare',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=');
echo $response->getBody();setUrl('{{baseUrl}}/getRegionBrandMarketShare');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'brandName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getRegionBrandMarketShare');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'brandName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getRegionBrandMarketShare?jwt=&brandName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getRegionBrandMarketShare"
querystring = {"jwt":"","brandName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getRegionBrandMarketShare"
queryString <- list(
jwt = "",
brandName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getRegionBrandMarketShare') do |req|
req.params['jwt'] = ''
req.params['brandName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getRegionBrandMarketShare";
let querystring = [
("jwt", ""),
("brandName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName='http GET '{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getRegionBrandMarketShare?jwt=&brandName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getRegionMarketShare?jwt=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getRegionMarketShare" {:query-params {:jwt ""}})require "http/client"
url = "{{baseUrl}}/getRegionMarketShare?jwt="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getRegionMarketShare?jwt="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getRegionMarketShare?jwt=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getRegionMarketShare?jwt="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getRegionMarketShare?jwt= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getRegionMarketShare?jwt=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getRegionMarketShare?jwt="))
.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}}/getRegionMarketShare?jwt=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getRegionMarketShare?jwt=")
.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}}/getRegionMarketShare?jwt=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getRegionMarketShare',
params: {jwt: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getRegionMarketShare?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getRegionMarketShare?jwt=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getRegionMarketShare?jwt=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getRegionMarketShare?jwt=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/getRegionMarketShare',
qs: {jwt: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/getRegionMarketShare');
req.query({
jwt: ''
});
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}}/getRegionMarketShare',
params: {jwt: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getRegionMarketShare?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getRegionMarketShare?jwt="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getRegionMarketShare?jwt=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getRegionMarketShare?jwt=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getRegionMarketShare?jwt=');
echo $response->getBody();setUrl('{{baseUrl}}/getRegionMarketShare');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getRegionMarketShare');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getRegionMarketShare?jwt=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getRegionMarketShare?jwt=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getRegionMarketShare?jwt=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getRegionMarketShare"
querystring = {"jwt":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getRegionMarketShare"
queryString <- list(jwt = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getRegionMarketShare?jwt=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getRegionMarketShare') do |req|
req.params['jwt'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getRegionMarketShare";
let querystring = [
("jwt", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getRegionMarketShare?jwt='http GET '{{baseUrl}}/getRegionMarketShare?jwt='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getRegionMarketShare?jwt='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getRegionMarketShare?jwt=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/regionSales" {:query-params {:jwt ""
:brandName ""
:regionName ""
:month ""}})require "http/client"
url = "{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/regionSales?jwt=&brandName=®ionName=&month= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month="))
.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}}/regionSales?jwt=&brandName=®ionName=&month=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=")
.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}}/regionSales?jwt=&brandName=®ionName=&month=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/regionSales',
params: {jwt: '', brandName: '', regionName: '', month: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/regionSales?jwt=&brandName=®ionName=&month=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/regionSales',
qs: {jwt: '', brandName: '', regionName: '', month: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/regionSales');
req.query({
jwt: '',
brandName: '',
regionName: '',
month: ''
});
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}}/regionSales',
params: {jwt: '', brandName: '', regionName: '', month: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=');
echo $response->getBody();setUrl('{{baseUrl}}/regionSales');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'brandName' => '',
'regionName' => '',
'month' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/regionSales');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'brandName' => '',
'regionName' => '',
'month' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/regionSales?jwt=&brandName=®ionName=&month=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/regionSales"
querystring = {"jwt":"","brandName":"","regionName":"","month":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/regionSales"
queryString <- list(
jwt = "",
brandName = "",
regionName = "",
month = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/regionSales') do |req|
req.params['jwt'] = ''
req.params['brandName'] = ''
req.params['regionName'] = ''
req.params['month'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/regionSales";
let querystring = [
("jwt", ""),
("brandName", ""),
("regionName", ""),
("month", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month='http GET '{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/regionSales?jwt=&brandName=®ionName=&month=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Top models in a given region
{{baseUrl}}/topModels
QUERY PARAMS
jwt
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/topModels?jwt=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/topModels" {:query-params {:jwt ""}})require "http/client"
url = "{{baseUrl}}/topModels?jwt="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/topModels?jwt="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/topModels?jwt=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/topModels?jwt="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/topModels?jwt= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/topModels?jwt=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/topModels?jwt="))
.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}}/topModels?jwt=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/topModels?jwt=")
.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}}/topModels?jwt=');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/topModels', params: {jwt: ''}};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/topModels?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/topModels?jwt=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/topModels?jwt=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/topModels?jwt=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/topModels', qs: {jwt: ''}};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/topModels');
req.query({
jwt: ''
});
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}}/topModels', params: {jwt: ''}};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/topModels?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/topModels?jwt="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/topModels?jwt=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/topModels?jwt=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/topModels?jwt=');
echo $response->getBody();setUrl('{{baseUrl}}/topModels');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/topModels');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/topModels?jwt=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/topModels?jwt=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/topModels?jwt=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/topModels"
querystring = {"jwt":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/topModels"
queryString <- list(jwt = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/topModels?jwt=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/topModels') do |req|
req.params['jwt'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/topModels";
let querystring = [
("jwt", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/topModels?jwt='http GET '{{baseUrl}}/topModels?jwt='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/topModels?jwt='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/topModels?jwt=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/modelYearDist" {:query-params {:jwt ""
:modelName ""
:brandName ""}})require "http/client"
url = "{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/modelYearDist?jwt=&modelName=&brandName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName="))
.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}}/modelYearDist?jwt=&modelName=&brandName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=")
.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}}/modelYearDist?jwt=&modelName=&brandName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/modelYearDist',
params: {jwt: '', modelName: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/modelYearDist?jwt=&modelName=&brandName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/modelYearDist',
qs: {jwt: '', modelName: '', brandName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/modelYearDist');
req.query({
jwt: '',
modelName: '',
brandName: ''
});
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}}/modelYearDist',
params: {jwt: '', modelName: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=');
echo $response->getBody();setUrl('{{baseUrl}}/modelYearDist');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'modelName' => '',
'brandName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/modelYearDist');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'modelName' => '',
'brandName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/modelYearDist?jwt=&modelName=&brandName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/modelYearDist"
querystring = {"jwt":"","modelName":"","brandName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/modelYearDist"
queryString <- list(
jwt = "",
modelName = "",
brandName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/modelYearDist') do |req|
req.params['jwt'] = ''
req.params['modelName'] = ''
req.params['brandName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/modelYearDist";
let querystring = [
("jwt", ""),
("modelName", ""),
("brandName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName='http GET '{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/modelYearDist?jwt=&modelName=&brandName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get a list of brand names
{{baseUrl}}/getBrands
QUERY PARAMS
jwt
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getBrands?jwt=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getBrands" {:query-params {:jwt ""}})require "http/client"
url = "{{baseUrl}}/getBrands?jwt="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getBrands?jwt="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getBrands?jwt=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getBrands?jwt="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getBrands?jwt= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getBrands?jwt=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getBrands?jwt="))
.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}}/getBrands?jwt=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getBrands?jwt=")
.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}}/getBrands?jwt=');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/getBrands', params: {jwt: ''}};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getBrands?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getBrands?jwt=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getBrands?jwt=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getBrands?jwt=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/getBrands', qs: {jwt: ''}};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/getBrands');
req.query({
jwt: ''
});
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}}/getBrands', params: {jwt: ''}};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getBrands?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getBrands?jwt="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getBrands?jwt=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getBrands?jwt=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getBrands?jwt=');
echo $response->getBody();setUrl('{{baseUrl}}/getBrands');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getBrands');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getBrands?jwt=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getBrands?jwt=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getBrands?jwt=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getBrands"
querystring = {"jwt":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getBrands"
queryString <- list(jwt = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getBrands?jwt=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getBrands') do |req|
req.params['jwt'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getBrands";
let querystring = [
("jwt", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getBrands?jwt='http GET '{{baseUrl}}/getBrands?jwt='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getBrands?jwt='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getBrands?jwt=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get a list of model names including discontinued models
{{baseUrl}}/getInactiveModels
QUERY PARAMS
jwt
brandName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getInactiveModels?jwt=&brandName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getInactiveModels" {:query-params {:jwt ""
:brandName ""}})require "http/client"
url = "{{baseUrl}}/getInactiveModels?jwt=&brandName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getInactiveModels?jwt=&brandName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getInactiveModels?jwt=&brandName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getInactiveModels?jwt=&brandName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getInactiveModels?jwt=&brandName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getInactiveModels?jwt=&brandName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getInactiveModels?jwt=&brandName="))
.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}}/getInactiveModels?jwt=&brandName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getInactiveModels?jwt=&brandName=")
.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}}/getInactiveModels?jwt=&brandName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getInactiveModels',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getInactiveModels?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getInactiveModels?jwt=&brandName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getInactiveModels?jwt=&brandName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getInactiveModels?jwt=&brandName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/getInactiveModels',
qs: {jwt: '', brandName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/getInactiveModels');
req.query({
jwt: '',
brandName: ''
});
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}}/getInactiveModels',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getInactiveModels?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getInactiveModels?jwt=&brandName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getInactiveModels?jwt=&brandName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getInactiveModels?jwt=&brandName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getInactiveModels?jwt=&brandName=');
echo $response->getBody();setUrl('{{baseUrl}}/getInactiveModels');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'brandName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getInactiveModels');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'brandName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getInactiveModels?jwt=&brandName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getInactiveModels?jwt=&brandName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getInactiveModels?jwt=&brandName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getInactiveModels"
querystring = {"jwt":"","brandName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getInactiveModels"
queryString <- list(
jwt = "",
brandName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getInactiveModels?jwt=&brandName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getInactiveModels') do |req|
req.params['jwt'] = ''
req.params['brandName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getInactiveModels";
let querystring = [
("jwt", ""),
("brandName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getInactiveModels?jwt=&brandName='http GET '{{baseUrl}}/getInactiveModels?jwt=&brandName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getInactiveModels?jwt=&brandName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getInactiveModels?jwt=&brandName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get a list of model names
{{baseUrl}}/getModels
QUERY PARAMS
jwt
brandName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getModels?jwt=&brandName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getModels" {:query-params {:jwt ""
:brandName ""}})require "http/client"
url = "{{baseUrl}}/getModels?jwt=&brandName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getModels?jwt=&brandName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getModels?jwt=&brandName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getModels?jwt=&brandName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getModels?jwt=&brandName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getModels?jwt=&brandName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getModels?jwt=&brandName="))
.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}}/getModels?jwt=&brandName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getModels?jwt=&brandName=")
.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}}/getModels?jwt=&brandName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getModels',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getModels?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getModels?jwt=&brandName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getModels?jwt=&brandName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getModels?jwt=&brandName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/getModels',
qs: {jwt: '', brandName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/getModels');
req.query({
jwt: '',
brandName: ''
});
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}}/getModels',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getModels?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getModels?jwt=&brandName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getModels?jwt=&brandName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getModels?jwt=&brandName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getModels?jwt=&brandName=');
echo $response->getBody();setUrl('{{baseUrl}}/getModels');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'brandName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getModels');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'brandName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getModels?jwt=&brandName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getModels?jwt=&brandName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getModels?jwt=&brandName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getModels"
querystring = {"jwt":"","brandName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getModels"
queryString <- list(
jwt = "",
brandName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getModels?jwt=&brandName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getModels') do |req|
req.params['jwt'] = ''
req.params['brandName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getModels";
let querystring = [
("jwt", ""),
("brandName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getModels?jwt=&brandName='http GET '{{baseUrl}}/getModels?jwt=&brandName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getModels?jwt=&brandName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getModels?jwt=&brandName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get a list of region names
{{baseUrl}}/getRegions
QUERY PARAMS
jwt
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/getRegions?jwt=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/getRegions" {:query-params {:jwt ""}})require "http/client"
url = "{{baseUrl}}/getRegions?jwt="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/getRegions?jwt="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/getRegions?jwt=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/getRegions?jwt="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/getRegions?jwt= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/getRegions?jwt=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/getRegions?jwt="))
.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}}/getRegions?jwt=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/getRegions?jwt=")
.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}}/getRegions?jwt=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/getRegions',
params: {jwt: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/getRegions?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/getRegions?jwt=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/getRegions?jwt=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/getRegions?jwt=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/getRegions', qs: {jwt: ''}};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/getRegions');
req.query({
jwt: ''
});
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}}/getRegions',
params: {jwt: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/getRegions?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/getRegions?jwt="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/getRegions?jwt=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/getRegions?jwt=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/getRegions?jwt=');
echo $response->getBody();setUrl('{{baseUrl}}/getRegions');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/getRegions');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/getRegions?jwt=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/getRegions?jwt=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/getRegions?jwt=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/getRegions"
querystring = {"jwt":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/getRegions"
queryString <- list(jwt = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/getRegions?jwt=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/getRegions') do |req|
req.params['jwt'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/getRegions";
let querystring = [
("jwt", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/getRegions?jwt='http GET '{{baseUrl}}/getRegions?jwt='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/getRegions?jwt='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/getRegions?jwt=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Days a vehicle takes to sell
{{baseUrl}}/daysToSell
QUERY PARAMS
jwt
brandName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/daysToSell?jwt=&brandName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/daysToSell" {:query-params {:jwt ""
:brandName ""}})require "http/client"
url = "{{baseUrl}}/daysToSell?jwt=&brandName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/daysToSell?jwt=&brandName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/daysToSell?jwt=&brandName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/daysToSell?jwt=&brandName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/daysToSell?jwt=&brandName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/daysToSell?jwt=&brandName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/daysToSell?jwt=&brandName="))
.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}}/daysToSell?jwt=&brandName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/daysToSell?jwt=&brandName=")
.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}}/daysToSell?jwt=&brandName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/daysToSell',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/daysToSell?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/daysToSell?jwt=&brandName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/daysToSell?jwt=&brandName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/daysToSell?jwt=&brandName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/daysToSell',
qs: {jwt: '', brandName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/daysToSell');
req.query({
jwt: '',
brandName: ''
});
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}}/daysToSell',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/daysToSell?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/daysToSell?jwt=&brandName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/daysToSell?jwt=&brandName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/daysToSell?jwt=&brandName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/daysToSell?jwt=&brandName=');
echo $response->getBody();setUrl('{{baseUrl}}/daysToSell');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'brandName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/daysToSell');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'brandName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/daysToSell?jwt=&brandName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/daysToSell?jwt=&brandName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/daysToSell?jwt=&brandName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/daysToSell"
querystring = {"jwt":"","brandName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/daysToSell"
queryString <- list(
jwt = "",
brandName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/daysToSell?jwt=&brandName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/daysToSell') do |req|
req.params['jwt'] = ''
req.params['brandName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/daysToSell";
let querystring = [
("jwt", ""),
("brandName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/daysToSell?jwt=&brandName='http GET '{{baseUrl}}/daysToSell?jwt=&brandName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/daysToSell?jwt=&brandName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/daysToSell?jwt=&brandName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Days worth of supply left on dealer lots
{{baseUrl}}/daysSupply
QUERY PARAMS
jwt
brandName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/daysSupply?jwt=&brandName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/daysSupply" {:query-params {:jwt ""
:brandName ""}})require "http/client"
url = "{{baseUrl}}/daysSupply?jwt=&brandName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/daysSupply?jwt=&brandName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/daysSupply?jwt=&brandName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/daysSupply?jwt=&brandName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/daysSupply?jwt=&brandName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/daysSupply?jwt=&brandName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/daysSupply?jwt=&brandName="))
.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}}/daysSupply?jwt=&brandName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/daysSupply?jwt=&brandName=")
.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}}/daysSupply?jwt=&brandName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/daysSupply',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/daysSupply?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/daysSupply?jwt=&brandName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/daysSupply?jwt=&brandName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/daysSupply?jwt=&brandName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/daysSupply',
qs: {jwt: '', brandName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/daysSupply');
req.query({
jwt: '',
brandName: ''
});
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}}/daysSupply',
params: {jwt: '', brandName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/daysSupply?jwt=&brandName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/daysSupply?jwt=&brandName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/daysSupply?jwt=&brandName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/daysSupply?jwt=&brandName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/daysSupply?jwt=&brandName=');
echo $response->getBody();setUrl('{{baseUrl}}/daysSupply');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'brandName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/daysSupply');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'brandName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/daysSupply?jwt=&brandName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/daysSupply?jwt=&brandName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/daysSupply?jwt=&brandName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/daysSupply"
querystring = {"jwt":"","brandName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/daysSupply"
queryString <- list(
jwt = "",
brandName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/daysSupply?jwt=&brandName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/daysSupply') do |req|
req.params['jwt'] = ''
req.params['brandName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/daysSupply";
let querystring = [
("jwt", ""),
("brandName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/daysSupply?jwt=&brandName='http GET '{{baseUrl}}/daysSupply?jwt=&brandName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/daysSupply?jwt=&brandName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/daysSupply?jwt=&brandName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Checks if a VIN appeared on the market on or after a given date.
{{baseUrl}}/vehicleSeen
QUERY PARAMS
jwt
vin
afterDate
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/vehicleSeen" {:query-params {:jwt ""
:vin ""
:afterDate ""}})require "http/client"
url = "{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/vehicleSeen?jwt=&vin=&afterDate= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate="))
.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}}/vehicleSeen?jwt=&vin=&afterDate=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=")
.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}}/vehicleSeen?jwt=&vin=&afterDate=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/vehicleSeen',
params: {jwt: '', vin: '', afterDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/vehicleSeen?jwt=&vin=&afterDate=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/vehicleSeen',
qs: {jwt: '', vin: '', afterDate: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/vehicleSeen');
req.query({
jwt: '',
vin: '',
afterDate: ''
});
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}}/vehicleSeen',
params: {jwt: '', vin: '', afterDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=');
echo $response->getBody();setUrl('{{baseUrl}}/vehicleSeen');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'vin' => '',
'afterDate' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/vehicleSeen');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'vin' => '',
'afterDate' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/vehicleSeen?jwt=&vin=&afterDate=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/vehicleSeen"
querystring = {"jwt":"","vin":"","afterDate":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/vehicleSeen"
queryString <- list(
jwt = "",
vin = "",
afterDate = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/vehicleSeen') do |req|
req.params['jwt'] = ''
req.params['vin'] = ''
req.params['afterDate'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/vehicleSeen";
let querystring = [
("jwt", ""),
("vin", ""),
("afterDate", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate='http GET '{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vehicleSeen?jwt=&vin=&afterDate=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Flexible Listing Search
{{baseUrl}}/listings2
QUERY PARAMS
jwt
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings2?jwt=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/listings2" {:query-params {:jwt ""}})require "http/client"
url = "{{baseUrl}}/listings2?jwt="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/listings2?jwt="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/listings2?jwt=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/listings2?jwt="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/listings2?jwt= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings2?jwt=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/listings2?jwt="))
.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}}/listings2?jwt=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/listings2?jwt=")
.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}}/listings2?jwt=');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/listings2', params: {jwt: ''}};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/listings2?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/listings2?jwt=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/listings2?jwt=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/listings2?jwt=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'GET', url: '{{baseUrl}}/listings2', qs: {jwt: ''}};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/listings2');
req.query({
jwt: ''
});
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}}/listings2', params: {jwt: ''}};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/listings2?jwt=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings2?jwt="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/listings2?jwt=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/listings2?jwt=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/listings2?jwt=');
echo $response->getBody();setUrl('{{baseUrl}}/listings2');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/listings2');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings2?jwt=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/listings2?jwt=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/listings2?jwt=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/listings2"
querystring = {"jwt":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/listings2"
queryString <- list(jwt = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/listings2?jwt=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/listings2') do |req|
req.params['jwt'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/listings2";
let querystring = [
("jwt", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/listings2?jwt='http GET '{{baseUrl}}/listings2?jwt='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/listings2?jwt='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings2?jwt=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Listings by Dealer ID and Date
{{baseUrl}}/listingsByDate
QUERY PARAMS
jwt
dealerID
startDate
endDate
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/listingsByDate" {:query-params {:jwt ""
:dealerID ""
:startDate ""
:endDate ""}})require "http/client"
url = "{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/listingsByDate?jwt=&dealerID=&startDate=&endDate= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate="))
.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}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=")
.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}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByDate',
params: {jwt: '', dealerID: '', startDate: '', endDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/listingsByDate?jwt=&dealerID=&startDate=&endDate=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByDate',
qs: {jwt: '', dealerID: '', startDate: '', endDate: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/listingsByDate');
req.query({
jwt: '',
dealerID: '',
startDate: '',
endDate: ''
});
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}}/listingsByDate',
params: {jwt: '', dealerID: '', startDate: '', endDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=');
echo $response->getBody();setUrl('{{baseUrl}}/listingsByDate');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'dealerID' => '',
'startDate' => '',
'endDate' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/listingsByDate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'dealerID' => '',
'startDate' => '',
'endDate' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/listingsByDate?jwt=&dealerID=&startDate=&endDate=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/listingsByDate"
querystring = {"jwt":"","dealerID":"","startDate":"","endDate":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/listingsByDate"
queryString <- list(
jwt = "",
dealerID = "",
startDate = "",
endDate = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/listingsByDate') do |req|
req.params['jwt'] = ''
req.params['dealerID'] = ''
req.params['startDate'] = ''
req.params['endDate'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/listingsByDate";
let querystring = [
("jwt", ""),
("dealerID", ""),
("startDate", ""),
("endDate", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate='http GET '{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listingsByDate?jwt=&dealerID=&startDate=&endDate=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Listings by Dealer ID
{{baseUrl}}/listings
QUERY PARAMS
jwt
dealerID
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listings?jwt=&dealerID=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/listings" {:query-params {:jwt ""
:dealerID ""}})require "http/client"
url = "{{baseUrl}}/listings?jwt=&dealerID="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/listings?jwt=&dealerID="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/listings?jwt=&dealerID=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/listings?jwt=&dealerID="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/listings?jwt=&dealerID= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listings?jwt=&dealerID=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/listings?jwt=&dealerID="))
.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}}/listings?jwt=&dealerID=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/listings?jwt=&dealerID=")
.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}}/listings?jwt=&dealerID=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/listings',
params: {jwt: '', dealerID: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/listings?jwt=&dealerID=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/listings?jwt=&dealerID=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/listings?jwt=&dealerID=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/listings?jwt=&dealerID=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/listings',
qs: {jwt: '', dealerID: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/listings');
req.query({
jwt: '',
dealerID: ''
});
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}}/listings',
params: {jwt: '', dealerID: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/listings?jwt=&dealerID=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listings?jwt=&dealerID="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/listings?jwt=&dealerID=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/listings?jwt=&dealerID=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/listings?jwt=&dealerID=');
echo $response->getBody();setUrl('{{baseUrl}}/listings');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'dealerID' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/listings');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'dealerID' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/listings?jwt=&dealerID=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/listings?jwt=&dealerID=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/listings?jwt=&dealerID=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/listings"
querystring = {"jwt":"","dealerID":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/listings"
queryString <- list(
jwt = "",
dealerID = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/listings?jwt=&dealerID=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/listings') do |req|
req.params['jwt'] = ''
req.params['dealerID'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/listings";
let querystring = [
("jwt", ""),
("dealerID", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/listings?jwt=&dealerID='http GET '{{baseUrl}}/listings?jwt=&dealerID='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/listings?jwt=&dealerID='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listings?jwt=&dealerID=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Listings by Region and Date
{{baseUrl}}/listingsByRegionAndDate
QUERY PARAMS
jwt
regionName
modelName
startDate
endDate
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/listingsByRegionAndDate" {:query-params {:jwt ""
:regionName ""
:modelName ""
:startDate ""
:endDate ""}})require "http/client"
url = "{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate="))
.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}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=")
.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}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByRegionAndDate',
params: {jwt: '', regionName: '', modelName: '', startDate: '', endDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByRegionAndDate',
qs: {jwt: '', regionName: '', modelName: '', startDate: '', endDate: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/listingsByRegionAndDate');
req.query({
jwt: '',
regionName: '',
modelName: '',
startDate: '',
endDate: ''
});
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}}/listingsByRegionAndDate',
params: {jwt: '', regionName: '', modelName: '', startDate: '', endDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=');
echo $response->getBody();setUrl('{{baseUrl}}/listingsByRegionAndDate');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'regionName' => '',
'modelName' => '',
'startDate' => '',
'endDate' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/listingsByRegionAndDate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'regionName' => '',
'modelName' => '',
'startDate' => '',
'endDate' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/listingsByRegionAndDate"
querystring = {"jwt":"","regionName":"","modelName":"","startDate":"","endDate":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/listingsByRegionAndDate"
queryString <- list(
jwt = "",
regionName = "",
modelName = "",
startDate = "",
endDate = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/listingsByRegionAndDate') do |req|
req.params['jwt'] = ''
req.params['regionName'] = ''
req.params['modelName'] = ''
req.params['startDate'] = ''
req.params['endDate'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/listingsByRegionAndDate";
let querystring = [
("jwt", ""),
("regionName", ""),
("modelName", ""),
("startDate", ""),
("endDate", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate='http GET '{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listingsByRegionAndDate?jwt=®ionName=&modelName=&startDate=&endDate=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Listings by Region
{{baseUrl}}/listingsByRegion
QUERY PARAMS
jwt
regionName
modelName
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/listingsByRegion" {:query-params {:jwt ""
:regionName ""
:modelName ""}})require "http/client"
url = "{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/listingsByRegion?jwt=®ionName=&modelName= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName="))
.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}}/listingsByRegion?jwt=®ionName=&modelName=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=")
.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}}/listingsByRegion?jwt=®ionName=&modelName=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByRegion',
params: {jwt: '', regionName: '', modelName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/listingsByRegion?jwt=®ionName=&modelName=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByRegion',
qs: {jwt: '', regionName: '', modelName: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/listingsByRegion');
req.query({
jwt: '',
regionName: '',
modelName: ''
});
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}}/listingsByRegion',
params: {jwt: '', regionName: '', modelName: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=');
echo $response->getBody();setUrl('{{baseUrl}}/listingsByRegion');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'regionName' => '',
'modelName' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/listingsByRegion');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'regionName' => '',
'modelName' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/listingsByRegion?jwt=®ionName=&modelName=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/listingsByRegion"
querystring = {"jwt":"","regionName":"","modelName":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/listingsByRegion"
queryString <- list(
jwt = "",
regionName = "",
modelName = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/listingsByRegion') do |req|
req.params['jwt'] = ''
req.params['regionName'] = ''
req.params['modelName'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/listingsByRegion";
let querystring = [
("jwt", ""),
("regionName", ""),
("modelName", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName='http GET '{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listingsByRegion?jwt=®ionName=&modelName=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Listings by ZipCode and Date
{{baseUrl}}/listingsByZipCodeAndDate
QUERY PARAMS
jwt
zipCode
startDate
endDate
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/listingsByZipCodeAndDate" {:query-params {:jwt ""
:zipCode ""
:startDate ""
:endDate ""}})require "http/client"
url = "{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate="))
.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}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=")
.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}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByZipCodeAndDate',
params: {jwt: '', zipCode: '', startDate: '', endDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByZipCodeAndDate',
qs: {jwt: '', zipCode: '', startDate: '', endDate: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/listingsByZipCodeAndDate');
req.query({
jwt: '',
zipCode: '',
startDate: '',
endDate: ''
});
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}}/listingsByZipCodeAndDate',
params: {jwt: '', zipCode: '', startDate: '', endDate: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=');
echo $response->getBody();setUrl('{{baseUrl}}/listingsByZipCodeAndDate');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'zipCode' => '',
'startDate' => '',
'endDate' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/listingsByZipCodeAndDate');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'zipCode' => '',
'startDate' => '',
'endDate' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/listingsByZipCodeAndDate"
querystring = {"jwt":"","zipCode":"","startDate":"","endDate":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/listingsByZipCodeAndDate"
queryString <- list(
jwt = "",
zipCode = "",
startDate = "",
endDate = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/listingsByZipCodeAndDate') do |req|
req.params['jwt'] = ''
req.params['zipCode'] = ''
req.params['startDate'] = ''
req.params['endDate'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/listingsByZipCodeAndDate";
let querystring = [
("jwt", ""),
("zipCode", ""),
("startDate", ""),
("endDate", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate='http GET '{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listingsByZipCodeAndDate?jwt=&zipCode=&startDate=&endDate=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Listings by ZipCode
{{baseUrl}}/listingsByZipCode
QUERY PARAMS
jwt
zipCode
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/listingsByZipCode?jwt=&zipCode=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/listingsByZipCode" {:query-params {:jwt ""
:zipCode ""}})require "http/client"
url = "{{baseUrl}}/listingsByZipCode?jwt=&zipCode="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/listingsByZipCode?jwt=&zipCode="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/listingsByZipCode?jwt=&zipCode=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/listingsByZipCode?jwt=&zipCode="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/listingsByZipCode?jwt=&zipCode= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/listingsByZipCode?jwt=&zipCode=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/listingsByZipCode?jwt=&zipCode="))
.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}}/listingsByZipCode?jwt=&zipCode=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/listingsByZipCode?jwt=&zipCode=")
.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}}/listingsByZipCode?jwt=&zipCode=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByZipCode',
params: {jwt: '', zipCode: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/listingsByZipCode?jwt=&zipCode=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/listingsByZipCode?jwt=&zipCode=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/listingsByZipCode?jwt=&zipCode=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/listingsByZipCode?jwt=&zipCode=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/listingsByZipCode',
qs: {jwt: '', zipCode: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/listingsByZipCode');
req.query({
jwt: '',
zipCode: ''
});
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}}/listingsByZipCode',
params: {jwt: '', zipCode: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/listingsByZipCode?jwt=&zipCode=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/listingsByZipCode?jwt=&zipCode="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/listingsByZipCode?jwt=&zipCode=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/listingsByZipCode?jwt=&zipCode=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/listingsByZipCode?jwt=&zipCode=');
echo $response->getBody();setUrl('{{baseUrl}}/listingsByZipCode');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'zipCode' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/listingsByZipCode');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'zipCode' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/listingsByZipCode?jwt=&zipCode=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/listingsByZipCode?jwt=&zipCode=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/listingsByZipCode?jwt=&zipCode=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/listingsByZipCode"
querystring = {"jwt":"","zipCode":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/listingsByZipCode"
queryString <- list(
jwt = "",
zipCode = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/listingsByZipCode?jwt=&zipCode=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/listingsByZipCode') do |req|
req.params['jwt'] = ''
req.params['zipCode'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/listingsByZipCode";
let querystring = [
("jwt", ""),
("zipCode", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/listingsByZipCode?jwt=&zipCode='http GET '{{baseUrl}}/listingsByZipCode?jwt=&zipCode='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/listingsByZipCode?jwt=&zipCode='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/listingsByZipCode?jwt=&zipCode=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vehicleHistory?jwt=&vin=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/vehicleHistory" {:query-params {:jwt ""
:vin ""}})require "http/client"
url = "{{baseUrl}}/vehicleHistory?jwt=&vin="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/vehicleHistory?jwt=&vin="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/vehicleHistory?jwt=&vin=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/vehicleHistory?jwt=&vin="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/vehicleHistory?jwt=&vin= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vehicleHistory?jwt=&vin=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/vehicleHistory?jwt=&vin="))
.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}}/vehicleHistory?jwt=&vin=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/vehicleHistory?jwt=&vin=")
.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}}/vehicleHistory?jwt=&vin=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/vehicleHistory',
params: {jwt: '', vin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/vehicleHistory?jwt=&vin=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/vehicleHistory?jwt=&vin=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/vehicleHistory?jwt=&vin=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/vehicleHistory?jwt=&vin=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/vehicleHistory',
qs: {jwt: '', vin: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/vehicleHistory');
req.query({
jwt: '',
vin: ''
});
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}}/vehicleHistory',
params: {jwt: '', vin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/vehicleHistory?jwt=&vin=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vehicleHistory?jwt=&vin="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/vehicleHistory?jwt=&vin=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/vehicleHistory?jwt=&vin=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/vehicleHistory?jwt=&vin=');
echo $response->getBody();setUrl('{{baseUrl}}/vehicleHistory');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'vin' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/vehicleHistory');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'vin' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/vehicleHistory?jwt=&vin=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/vehicleHistory?jwt=&vin=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/vehicleHistory?jwt=&vin=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/vehicleHistory"
querystring = {"jwt":"","vin":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/vehicleHistory"
queryString <- list(
jwt = "",
vin = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/vehicleHistory?jwt=&vin=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/vehicleHistory') do |req|
req.params['jwt'] = ''
req.params['vin'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/vehicleHistory";
let querystring = [
("jwt", ""),
("vin", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/vehicleHistory?jwt=&vin='http GET '{{baseUrl}}/vehicleHistory?jwt=&vin='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/vehicleHistory?jwt=&vin='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vehicleHistory?jwt=&vin=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/valuation?jwt=&vin=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/valuation" {:query-params {:jwt ""
:vin ""}})require "http/client"
url = "{{baseUrl}}/valuation?jwt=&vin="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/valuation?jwt=&vin="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/valuation?jwt=&vin=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/valuation?jwt=&vin="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/valuation?jwt=&vin= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/valuation?jwt=&vin=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/valuation?jwt=&vin="))
.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}}/valuation?jwt=&vin=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/valuation?jwt=&vin=")
.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}}/valuation?jwt=&vin=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/valuation',
params: {jwt: '', vin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/valuation?jwt=&vin=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/valuation?jwt=&vin=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/valuation?jwt=&vin=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/valuation?jwt=&vin=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/valuation',
qs: {jwt: '', vin: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/valuation');
req.query({
jwt: '',
vin: ''
});
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}}/valuation',
params: {jwt: '', vin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/valuation?jwt=&vin=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/valuation?jwt=&vin="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/valuation?jwt=&vin=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/valuation?jwt=&vin=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/valuation?jwt=&vin=');
echo $response->getBody();setUrl('{{baseUrl}}/valuation');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'vin' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/valuation');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'vin' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/valuation?jwt=&vin=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/valuation?jwt=&vin=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/valuation?jwt=&vin=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/valuation"
querystring = {"jwt":"","vin":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/valuation"
queryString <- list(
jwt = "",
vin = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/valuation?jwt=&vin=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/valuation') do |req|
req.params['jwt'] = ''
req.params['vin'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/valuation";
let querystring = [
("jwt", ""),
("vin", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/valuation?jwt=&vin='http GET '{{baseUrl}}/valuation?jwt=&vin='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/valuation?jwt=&vin='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/valuation?jwt=&vin=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/similarSalePrice?jwt=&vin=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/similarSalePrice" {:query-params {:jwt ""
:vin ""}})require "http/client"
url = "{{baseUrl}}/similarSalePrice?jwt=&vin="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/similarSalePrice?jwt=&vin="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/similarSalePrice?jwt=&vin=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/similarSalePrice?jwt=&vin="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/similarSalePrice?jwt=&vin= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/similarSalePrice?jwt=&vin=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/similarSalePrice?jwt=&vin="))
.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}}/similarSalePrice?jwt=&vin=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/similarSalePrice?jwt=&vin=")
.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}}/similarSalePrice?jwt=&vin=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/similarSalePrice',
params: {jwt: '', vin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/similarSalePrice?jwt=&vin=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/similarSalePrice?jwt=&vin=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/similarSalePrice?jwt=&vin=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/similarSalePrice?jwt=&vin=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/similarSalePrice',
qs: {jwt: '', vin: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/similarSalePrice');
req.query({
jwt: '',
vin: ''
});
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}}/similarSalePrice',
params: {jwt: '', vin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/similarSalePrice?jwt=&vin=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/similarSalePrice?jwt=&vin="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/similarSalePrice?jwt=&vin=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/similarSalePrice?jwt=&vin=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/similarSalePrice?jwt=&vin=');
echo $response->getBody();setUrl('{{baseUrl}}/similarSalePrice');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'vin' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/similarSalePrice');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'vin' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/similarSalePrice?jwt=&vin=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/similarSalePrice?jwt=&vin=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/similarSalePrice?jwt=&vin=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/similarSalePrice"
querystring = {"jwt":"","vin":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/similarSalePrice"
queryString <- list(
jwt = "",
vin = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/similarSalePrice?jwt=&vin=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/similarSalePrice') do |req|
req.params['jwt'] = ''
req.params['vin'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/similarSalePrice";
let querystring = [
("jwt", ""),
("vin", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/similarSalePrice?jwt=&vin='http GET '{{baseUrl}}/similarSalePrice?jwt=&vin='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/similarSalePrice?jwt=&vin='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/similarSalePrice?jwt=&vin=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Vin decoder and Recall Info
{{baseUrl}}/vinDecode
QUERY PARAMS
jwt
vin
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/vinDecode?jwt=&vin=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/vinDecode" {:query-params {:jwt ""
:vin ""}})require "http/client"
url = "{{baseUrl}}/vinDecode?jwt=&vin="
response = HTTP::Client.get url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/vinDecode?jwt=&vin="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/vinDecode?jwt=&vin=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/vinDecode?jwt=&vin="
req, _ := http.NewRequest("GET", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/vinDecode?jwt=&vin= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/vinDecode?jwt=&vin=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/vinDecode?jwt=&vin="))
.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}}/vinDecode?jwt=&vin=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/vinDecode?jwt=&vin=")
.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}}/vinDecode?jwt=&vin=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/vinDecode',
params: {jwt: '', vin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/vinDecode?jwt=&vin=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/vinDecode?jwt=&vin=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/vinDecode?jwt=&vin=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/vinDecode?jwt=&vin=',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/vinDecode',
qs: {jwt: '', vin: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/vinDecode');
req.query({
jwt: '',
vin: ''
});
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}}/vinDecode',
params: {jwt: '', vin: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/vinDecode?jwt=&vin=';
const options = {method: 'GET'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vinDecode?jwt=&vin="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/vinDecode?jwt=&vin=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/vinDecode?jwt=&vin=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/vinDecode?jwt=&vin=');
echo $response->getBody();setUrl('{{baseUrl}}/vinDecode');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'jwt' => '',
'vin' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/vinDecode');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'jwt' => '',
'vin' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/vinDecode?jwt=&vin=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/vinDecode?jwt=&vin=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/vinDecode?jwt=&vin=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/vinDecode"
querystring = {"jwt":"","vin":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/vinDecode"
queryString <- list(
jwt = "",
vin = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/vinDecode?jwt=&vin=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/vinDecode') do |req|
req.params['jwt'] = ''
req.params['vin'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/vinDecode";
let querystring = [
("jwt", ""),
("vin", ""),
];
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/vinDecode?jwt=&vin='http GET '{{baseUrl}}/vinDecode?jwt=&vin='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/vinDecode?jwt=&vin='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vinDecode?jwt=&vin=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()