Mon-voyage-pas-cher.com Public API
GET
Retrieve cities informations from a string - build an autocomplete
{{baseUrl}}/cities/findcitiesfromtext
QUERY PARAMS
q
language
sort
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/cities/findcitiesfromtext" {:query-params {:q ""
:language ""
:sort ""}})require "http/client"
url = "{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort="
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}}/cities/findcitiesfromtext?q=&language=&sort="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort="
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/cities/findcitiesfromtext?q=&language=&sort= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort="))
.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}}/cities/findcitiesfromtext?q=&language=&sort=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=")
.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}}/cities/findcitiesfromtext?q=&language=&sort=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/cities/findcitiesfromtext',
params: {q: '', language: '', sort: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=';
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}}/cities/findcitiesfromtext?q=&language=&sort=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/cities/findcitiesfromtext?q=&language=&sort=',
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}}/cities/findcitiesfromtext',
qs: {q: '', language: '', sort: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/cities/findcitiesfromtext');
req.query({
q: '',
language: '',
sort: ''
});
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}}/cities/findcitiesfromtext',
params: {q: '', language: '', sort: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=';
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}}/cities/findcitiesfromtext?q=&language=&sort="]
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}}/cities/findcitiesfromtext?q=&language=&sort=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=",
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}}/cities/findcitiesfromtext?q=&language=&sort=');
echo $response->getBody();setUrl('{{baseUrl}}/cities/findcitiesfromtext');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'q' => '',
'language' => '',
'sort' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/cities/findcitiesfromtext');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'q' => '',
'language' => '',
'sort' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/cities/findcitiesfromtext?q=&language=&sort=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/cities/findcitiesfromtext"
querystring = {"q":"","language":"","sort":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/cities/findcitiesfromtext"
queryString <- list(
q = "",
language = "",
sort = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=")
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/cities/findcitiesfromtext') do |req|
req.params['q'] = ''
req.params['language'] = ''
req.params['sort'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/cities/findcitiesfromtext";
let querystring = [
("q", ""),
("language", ""),
("sort", ""),
];
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}}/cities/findcitiesfromtext?q=&language=&sort='http GET '{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cities/findcitiesfromtext?q=&language=&sort=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Search airports by country - Search nearby airports - Search an airport
{{baseUrl}}/airports
QUERY PARAMS
language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airports?language=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/airports" {:query-params {:language ""}})require "http/client"
url = "{{baseUrl}}/airports?language="
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}}/airports?language="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/airports?language=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/airports?language="
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/airports?language= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/airports?language=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/airports?language="))
.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}}/airports?language=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/airports?language=")
.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}}/airports?language=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/airports',
params: {language: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/airports?language=';
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}}/airports?language=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/airports?language=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/airports?language=',
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}}/airports', qs: {language: ''}};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/airports');
req.query({
language: ''
});
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}}/airports',
params: {language: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/airports?language=';
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}}/airports?language="]
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}}/airports?language=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/airports?language=",
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}}/airports?language=');
echo $response->getBody();setUrl('{{baseUrl}}/airports');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'language' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/airports');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'language' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/airports?language=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/airports?language=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/airports?language=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/airports"
querystring = {"language":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/airports"
queryString <- list(language = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/airports?language=")
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/airports') do |req|
req.params['language'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/airports";
let querystring = [
("language", ""),
];
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}}/airports?language='http GET '{{baseUrl}}/airports?language='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/airports?language='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airports?language=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Search all cities from lat-long or countrycode
{{baseUrl}}/cities/findcitiesfromlatlong
QUERY PARAMS
language
sort
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/cities/findcitiesfromlatlong" {:query-params {:language ""
:sort ""}})require "http/client"
url = "{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort="
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}}/cities/findcitiesfromlatlong?language=&sort="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort="
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/cities/findcitiesfromlatlong?language=&sort= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort="))
.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}}/cities/findcitiesfromlatlong?language=&sort=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=")
.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}}/cities/findcitiesfromlatlong?language=&sort=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/cities/findcitiesfromlatlong',
params: {language: '', sort: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=';
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}}/cities/findcitiesfromlatlong?language=&sort=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/cities/findcitiesfromlatlong?language=&sort=',
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}}/cities/findcitiesfromlatlong',
qs: {language: '', sort: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/cities/findcitiesfromlatlong');
req.query({
language: '',
sort: ''
});
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}}/cities/findcitiesfromlatlong',
params: {language: '', sort: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=';
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}}/cities/findcitiesfromlatlong?language=&sort="]
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}}/cities/findcitiesfromlatlong?language=&sort=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=",
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}}/cities/findcitiesfromlatlong?language=&sort=');
echo $response->getBody();setUrl('{{baseUrl}}/cities/findcitiesfromlatlong');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'language' => '',
'sort' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/cities/findcitiesfromlatlong');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'language' => '',
'sort' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/cities/findcitiesfromlatlong?language=&sort=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/cities/findcitiesfromlatlong"
querystring = {"language":"","sort":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/cities/findcitiesfromlatlong"
queryString <- list(
language = "",
sort = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=")
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/cities/findcitiesfromlatlong') do |req|
req.params['language'] = ''
req.params['sort'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/cities/findcitiesfromlatlong";
let querystring = [
("language", ""),
("sort", ""),
];
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}}/cities/findcitiesfromlatlong?language=&sort='http GET '{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cities/findcitiesfromlatlong?language=&sort=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Search all continents or one specific continent
{{baseUrl}}/continents
QUERY PARAMS
language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continents?language=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/continents" {:query-params {:language ""}})require "http/client"
url = "{{baseUrl}}/continents?language="
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}}/continents?language="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/continents?language=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/continents?language="
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/continents?language= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/continents?language=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/continents?language="))
.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}}/continents?language=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/continents?language=")
.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}}/continents?language=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/continents',
params: {language: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/continents?language=';
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}}/continents?language=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/continents?language=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/continents?language=',
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}}/continents',
qs: {language: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/continents');
req.query({
language: ''
});
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}}/continents',
params: {language: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/continents?language=';
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}}/continents?language="]
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}}/continents?language=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/continents?language=",
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}}/continents?language=');
echo $response->getBody();setUrl('{{baseUrl}}/continents');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'language' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/continents');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'language' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/continents?language=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/continents?language=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/continents?language=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/continents"
querystring = {"language":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/continents"
queryString <- list(language = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/continents?language=")
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/continents') do |req|
req.params['language'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/continents";
let querystring = [
("language", ""),
];
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}}/continents?language='http GET '{{baseUrl}}/continents?language='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/continents?language='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continents?language=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Search all countries or one specific country
{{baseUrl}}/countries
QUERY PARAMS
language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/countries?language=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/countries" {:query-params {:language ""}})require "http/client"
url = "{{baseUrl}}/countries?language="
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}}/countries?language="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/countries?language=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/countries?language="
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/countries?language= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/countries?language=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/countries?language="))
.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}}/countries?language=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/countries?language=")
.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}}/countries?language=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/countries',
params: {language: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/countries?language=';
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}}/countries?language=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/countries?language=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/countries?language=',
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}}/countries',
qs: {language: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/countries');
req.query({
language: ''
});
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}}/countries',
params: {language: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/countries?language=';
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}}/countries?language="]
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}}/countries?language=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/countries?language=",
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}}/countries?language=');
echo $response->getBody();setUrl('{{baseUrl}}/countries');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'language' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/countries');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'language' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/countries?language=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/countries?language=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/countries?language=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/countries"
querystring = {"language":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/countries"
queryString <- list(language = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/countries?language=")
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/countries') do |req|
req.params['language'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/countries";
let querystring = [
("language", ""),
];
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}}/countries?language='http GET '{{baseUrl}}/countries?language='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/countries?language='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/countries?language=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Search significant cities from lat-long or countrycode
{{baseUrl}}/cities/significant
QUERY PARAMS
language
sort
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cities/significant?language=&sort=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/cities/significant" {:query-params {:language ""
:sort ""}})require "http/client"
url = "{{baseUrl}}/cities/significant?language=&sort="
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}}/cities/significant?language=&sort="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/cities/significant?language=&sort=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/cities/significant?language=&sort="
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/cities/significant?language=&sort= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/cities/significant?language=&sort=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/cities/significant?language=&sort="))
.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}}/cities/significant?language=&sort=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/cities/significant?language=&sort=")
.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}}/cities/significant?language=&sort=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/cities/significant',
params: {language: '', sort: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/cities/significant?language=&sort=';
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}}/cities/significant?language=&sort=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/cities/significant?language=&sort=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/cities/significant?language=&sort=',
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}}/cities/significant',
qs: {language: '', sort: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/cities/significant');
req.query({
language: '',
sort: ''
});
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}}/cities/significant',
params: {language: '', sort: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/cities/significant?language=&sort=';
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}}/cities/significant?language=&sort="]
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}}/cities/significant?language=&sort=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/cities/significant?language=&sort=",
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}}/cities/significant?language=&sort=');
echo $response->getBody();setUrl('{{baseUrl}}/cities/significant');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'language' => '',
'sort' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/cities/significant');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'language' => '',
'sort' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/cities/significant?language=&sort=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/cities/significant?language=&sort=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/cities/significant?language=&sort=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/cities/significant"
querystring = {"language":"","sort":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/cities/significant"
queryString <- list(
language = "",
sort = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/cities/significant?language=&sort=")
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/cities/significant') do |req|
req.params['language'] = ''
req.params['sort'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/cities/significant";
let querystring = [
("language", ""),
("sort", ""),
];
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}}/cities/significant?language=&sort='http GET '{{baseUrl}}/cities/significant?language=&sort='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/cities/significant?language=&sort='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cities/significant?language=&sort=")! 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
Calculate distance between lats-longs
{{baseUrl}}/distance
QUERY PARAMS
locationA
locationB
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/distance?locationA=&locationB=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/distance" {:query-params {:locationA ""
:locationB ""}})require "http/client"
url = "{{baseUrl}}/distance?locationA=&locationB="
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}}/distance?locationA=&locationB="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/distance?locationA=&locationB=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/distance?locationA=&locationB="
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/distance?locationA=&locationB= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/distance?locationA=&locationB=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/distance?locationA=&locationB="))
.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}}/distance?locationA=&locationB=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/distance?locationA=&locationB=")
.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}}/distance?locationA=&locationB=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/distance',
params: {locationA: '', locationB: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/distance?locationA=&locationB=';
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}}/distance?locationA=&locationB=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/distance?locationA=&locationB=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/distance?locationA=&locationB=',
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}}/distance',
qs: {locationA: '', locationB: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/distance');
req.query({
locationA: '',
locationB: ''
});
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}}/distance',
params: {locationA: '', locationB: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/distance?locationA=&locationB=';
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}}/distance?locationA=&locationB="]
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}}/distance?locationA=&locationB=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/distance?locationA=&locationB=",
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}}/distance?locationA=&locationB=');
echo $response->getBody();setUrl('{{baseUrl}}/distance');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'locationA' => '',
'locationB' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/distance');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'locationA' => '',
'locationB' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/distance?locationA=&locationB=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/distance?locationA=&locationB=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/distance?locationA=&locationB=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/distance"
querystring = {"locationA":"","locationB":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/distance"
queryString <- list(
locationA = "",
locationB = ""
)
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/distance?locationA=&locationB=")
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/distance') do |req|
req.params['locationA'] = ''
req.params['locationB'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/distance";
let querystring = [
("locationA", ""),
("locationB", ""),
];
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}}/distance?locationA=&locationB='http GET '{{baseUrl}}/distance?locationA=&locationB='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/distance?locationA=&locationB='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/distance?locationA=&locationB=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Search elevation informations from lat-long
{{baseUrl}}/elevation
QUERY PARAMS
locations
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/elevation?locations=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/elevation" {:query-params {:locations ""}})require "http/client"
url = "{{baseUrl}}/elevation?locations="
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}}/elevation?locations="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/elevation?locations=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/elevation?locations="
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/elevation?locations= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/elevation?locations=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/elevation?locations="))
.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}}/elevation?locations=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/elevation?locations=")
.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}}/elevation?locations=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/elevation',
params: {locations: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/elevation?locations=';
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}}/elevation?locations=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/elevation?locations=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/elevation?locations=',
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}}/elevation',
qs: {locations: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/elevation');
req.query({
locations: ''
});
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}}/elevation',
params: {locations: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/elevation?locations=';
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}}/elevation?locations="]
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}}/elevation?locations=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/elevation?locations=",
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}}/elevation?locations=');
echo $response->getBody();setUrl('{{baseUrl}}/elevation');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'locations' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/elevation');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'locations' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/elevation?locations=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/elevation?locations=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/elevation?locations=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/elevation"
querystring = {"locations":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/elevation"
queryString <- list(locations = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/elevation?locations=")
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/elevation') do |req|
req.params['locations'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/elevation";
let querystring = [
("locations", ""),
];
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}}/elevation?locations='http GET '{{baseUrl}}/elevation?locations='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/elevation?locations='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/elevation?locations=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Search position of sun from lat-long and date
{{baseUrl}}/sun_positions
QUERY PARAMS
location
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sun_positions?location=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/sun_positions" {:query-params {:location ""}})require "http/client"
url = "{{baseUrl}}/sun_positions?location="
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}}/sun_positions?location="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/sun_positions?location=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/sun_positions?location="
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/sun_positions?location= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/sun_positions?location=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/sun_positions?location="))
.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}}/sun_positions?location=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/sun_positions?location=")
.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}}/sun_positions?location=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/sun_positions',
params: {location: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/sun_positions?location=';
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}}/sun_positions?location=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/sun_positions?location=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/sun_positions?location=',
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}}/sun_positions',
qs: {location: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/sun_positions');
req.query({
location: ''
});
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}}/sun_positions',
params: {location: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/sun_positions?location=';
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}}/sun_positions?location="]
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}}/sun_positions?location=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/sun_positions?location=",
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}}/sun_positions?location=');
echo $response->getBody();setUrl('{{baseUrl}}/sun_positions');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'location' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/sun_positions');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'location' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/sun_positions?location=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/sun_positions?location=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/sun_positions?location=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/sun_positions"
querystring = {"location":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/sun_positions"
queryString <- list(location = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/sun_positions?location=")
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/sun_positions') do |req|
req.params['location'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/sun_positions";
let querystring = [
("location", ""),
];
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}}/sun_positions?location='http GET '{{baseUrl}}/sun_positions?location='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/sun_positions?location='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sun_positions?location=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Search timezone and time informations from lat-long
{{baseUrl}}/timezone
QUERY PARAMS
location
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timezone?location=");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/timezone" {:query-params {:location ""}})require "http/client"
url = "{{baseUrl}}/timezone?location="
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}}/timezone?location="),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/timezone?location=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/timezone?location="
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/timezone?location= HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/timezone?location=")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/timezone?location="))
.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}}/timezone?location=")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/timezone?location=")
.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}}/timezone?location=');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/timezone',
params: {location: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/timezone?location=';
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}}/timezone?location=',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/timezone?location=")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/timezone?location=',
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}}/timezone', qs: {location: ''}};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/timezone');
req.query({
location: ''
});
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}}/timezone',
params: {location: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/timezone?location=';
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}}/timezone?location="]
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}}/timezone?location=" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/timezone?location=",
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}}/timezone?location=');
echo $response->getBody();setUrl('{{baseUrl}}/timezone');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'location' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/timezone');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'location' => ''
]));
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/timezone?location=' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/timezone?location=' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/timezone?location=")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/timezone"
querystring = {"location":""}
response = requests.get(url, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/timezone"
queryString <- list(location = "")
response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/timezone?location=")
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/timezone') do |req|
req.params['location'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/timezone";
let querystring = [
("location", ""),
];
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}}/timezone?location='http GET '{{baseUrl}}/timezone?location='wget --quiet \
--method GET \
--output-document \
- '{{baseUrl}}/timezone?location='import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timezone?location=")! 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
getPing
{{baseUrl}}/pong
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/pong");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/pong")require "http/client"
url = "{{baseUrl}}/pong"
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}}/pong"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/pong");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/pong"
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/pong HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/pong")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/pong"))
.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}}/pong")
.get()
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/pong")
.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}}/pong');
xhr.send(data);import axios from 'axios';
const options = {method: 'GET', url: '{{baseUrl}}/pong'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/pong';
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}}/pong',
method: 'GET',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/pong")
.get()
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/pong',
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}}/pong'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/pong');
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}}/pong'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/pong';
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}}/pong"]
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}}/pong" in
Client.call `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/pong",
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}}/pong');
echo $response->getBody();setUrl('{{baseUrl}}/pong');
$request->setMethod(HTTP_METH_GET);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/pong');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/pong' -Method GET $response = Invoke-RestMethod -Uri '{{baseUrl}}/pong' -Method GET import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("GET", "/baseUrl/pong")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/pong"
response = requests.get(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/pong"
response <- VERB("GET", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/pong")
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/pong') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/pong";
let client = reqwest::Client::new();
let response = client.get(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/ponghttp GET {{baseUrl}}/pongwget --quiet \
--method GET \
--output-document \
- {{baseUrl}}/pongimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/pong")! 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()
OPTIONS
CORS support (1)
{{baseUrl}}/cities/findcitiesfromtext
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cities/findcitiesfromtext");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/cities/findcitiesfromtext")require "http/client"
url = "{{baseUrl}}/cities/findcitiesfromtext"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/cities/findcitiesfromtext"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/cities/findcitiesfromtext");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/cities/findcitiesfromtext"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/cities/findcitiesfromtext HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/cities/findcitiesfromtext")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/cities/findcitiesfromtext"))
.method("OPTIONS", 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}}/cities/findcitiesfromtext")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/cities/findcitiesfromtext")
.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('OPTIONS', '{{baseUrl}}/cities/findcitiesfromtext');
xhr.send(data);import axios from 'axios';
const options = {
method: 'OPTIONS',
url: '{{baseUrl}}/cities/findcitiesfromtext'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/cities/findcitiesfromtext';
const options = {method: 'OPTIONS'};
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}}/cities/findcitiesfromtext',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/cities/findcitiesfromtext")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/cities/findcitiesfromtext',
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: 'OPTIONS',
url: '{{baseUrl}}/cities/findcitiesfromtext'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/cities/findcitiesfromtext');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'OPTIONS',
url: '{{baseUrl}}/cities/findcitiesfromtext'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/cities/findcitiesfromtext';
const options = {method: 'OPTIONS'};
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}}/cities/findcitiesfromtext"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/cities/findcitiesfromtext" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/cities/findcitiesfromtext",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/cities/findcitiesfromtext');
echo $response->getBody();setUrl('{{baseUrl}}/cities/findcitiesfromtext');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/cities/findcitiesfromtext');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/cities/findcitiesfromtext' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/cities/findcitiesfromtext' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/cities/findcitiesfromtext")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/cities/findcitiesfromtext"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/cities/findcitiesfromtext"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/cities/findcitiesfromtext")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/cities/findcitiesfromtext') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/cities/findcitiesfromtext";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/cities/findcitiesfromtexthttp OPTIONS {{baseUrl}}/cities/findcitiesfromtextwget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/cities/findcitiesfromtextimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cities/findcitiesfromtext")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()
OPTIONS
CORS support (2)
{{baseUrl}}/cities/significant
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cities/significant");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/cities/significant")require "http/client"
url = "{{baseUrl}}/cities/significant"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/cities/significant"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/cities/significant");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/cities/significant"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/cities/significant HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/cities/significant")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/cities/significant"))
.method("OPTIONS", 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}}/cities/significant")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/cities/significant")
.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('OPTIONS', '{{baseUrl}}/cities/significant');
xhr.send(data);import axios from 'axios';
const options = {method: 'OPTIONS', url: '{{baseUrl}}/cities/significant'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/cities/significant';
const options = {method: 'OPTIONS'};
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}}/cities/significant',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/cities/significant")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/cities/significant',
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: 'OPTIONS', url: '{{baseUrl}}/cities/significant'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/cities/significant');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'OPTIONS', url: '{{baseUrl}}/cities/significant'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/cities/significant';
const options = {method: 'OPTIONS'};
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}}/cities/significant"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/cities/significant" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/cities/significant",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/cities/significant');
echo $response->getBody();setUrl('{{baseUrl}}/cities/significant');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/cities/significant');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/cities/significant' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/cities/significant' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/cities/significant")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/cities/significant"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/cities/significant"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/cities/significant")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/cities/significant') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/cities/significant";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/cities/significanthttp OPTIONS {{baseUrl}}/cities/significantwget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/cities/significantimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cities/significant")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()
OPTIONS
CORS support (3)
{{baseUrl}}/continents
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/continents");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/continents")require "http/client"
url = "{{baseUrl}}/continents"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/continents"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/continents");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/continents"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/continents HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/continents")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/continents"))
.method("OPTIONS", 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}}/continents")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/continents")
.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('OPTIONS', '{{baseUrl}}/continents');
xhr.send(data);import axios from 'axios';
const options = {method: 'OPTIONS', url: '{{baseUrl}}/continents'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/continents';
const options = {method: 'OPTIONS'};
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}}/continents',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/continents")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/continents',
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: 'OPTIONS', url: '{{baseUrl}}/continents'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/continents');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'OPTIONS', url: '{{baseUrl}}/continents'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/continents';
const options = {method: 'OPTIONS'};
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}}/continents"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/continents" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/continents",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/continents');
echo $response->getBody();setUrl('{{baseUrl}}/continents');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/continents');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/continents' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/continents' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/continents")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/continents"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/continents"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/continents")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/continents') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/continents";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/continentshttp OPTIONS {{baseUrl}}/continentswget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/continentsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/continents")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()
OPTIONS
CORS support (4)
{{baseUrl}}/countries
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/countries");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/countries")require "http/client"
url = "{{baseUrl}}/countries"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/countries"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/countries");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/countries"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/countries HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/countries")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/countries"))
.method("OPTIONS", 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}}/countries")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/countries")
.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('OPTIONS', '{{baseUrl}}/countries');
xhr.send(data);import axios from 'axios';
const options = {method: 'OPTIONS', url: '{{baseUrl}}/countries'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/countries';
const options = {method: 'OPTIONS'};
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}}/countries',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/countries")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/countries',
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: 'OPTIONS', url: '{{baseUrl}}/countries'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/countries');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'OPTIONS', url: '{{baseUrl}}/countries'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/countries';
const options = {method: 'OPTIONS'};
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}}/countries"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/countries" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/countries",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/countries');
echo $response->getBody();setUrl('{{baseUrl}}/countries');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/countries');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/countries' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/countries' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/countries")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/countries"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/countries"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/countries")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/countries') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/countries";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/countrieshttp OPTIONS {{baseUrl}}/countrieswget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/countriesimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/countries")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()
OPTIONS
CORS support (5)
{{baseUrl}}/distance
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/distance");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/distance")require "http/client"
url = "{{baseUrl}}/distance"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/distance"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/distance");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/distance"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/distance HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/distance")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/distance"))
.method("OPTIONS", 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}}/distance")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/distance")
.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('OPTIONS', '{{baseUrl}}/distance');
xhr.send(data);import axios from 'axios';
const options = {method: 'OPTIONS', url: '{{baseUrl}}/distance'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/distance';
const options = {method: 'OPTIONS'};
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}}/distance',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/distance")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/distance',
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: 'OPTIONS', url: '{{baseUrl}}/distance'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/distance');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'OPTIONS', url: '{{baseUrl}}/distance'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/distance';
const options = {method: 'OPTIONS'};
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}}/distance"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/distance" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/distance",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/distance');
echo $response->getBody();setUrl('{{baseUrl}}/distance');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/distance');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/distance' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/distance' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/distance")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/distance"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/distance"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/distance")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/distance') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/distance";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/distancehttp OPTIONS {{baseUrl}}/distancewget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/distanceimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/distance")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()
OPTIONS
CORS support (6)
{{baseUrl}}/elevation
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/elevation");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/elevation")require "http/client"
url = "{{baseUrl}}/elevation"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/elevation"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/elevation");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/elevation"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/elevation HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/elevation")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/elevation"))
.method("OPTIONS", 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}}/elevation")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/elevation")
.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('OPTIONS', '{{baseUrl}}/elevation');
xhr.send(data);import axios from 'axios';
const options = {method: 'OPTIONS', url: '{{baseUrl}}/elevation'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/elevation';
const options = {method: 'OPTIONS'};
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}}/elevation',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/elevation")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/elevation',
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: 'OPTIONS', url: '{{baseUrl}}/elevation'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/elevation');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'OPTIONS', url: '{{baseUrl}}/elevation'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/elevation';
const options = {method: 'OPTIONS'};
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}}/elevation"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/elevation" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/elevation",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/elevation');
echo $response->getBody();setUrl('{{baseUrl}}/elevation');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/elevation');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/elevation' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/elevation' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/elevation")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/elevation"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/elevation"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/elevation")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/elevation') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/elevation";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/elevationhttp OPTIONS {{baseUrl}}/elevationwget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/elevationimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/elevation")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()
OPTIONS
CORS support (7)
{{baseUrl}}/sun_positions
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/sun_positions");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/sun_positions")require "http/client"
url = "{{baseUrl}}/sun_positions"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/sun_positions"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/sun_positions");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/sun_positions"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/sun_positions HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/sun_positions")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/sun_positions"))
.method("OPTIONS", 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}}/sun_positions")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/sun_positions")
.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('OPTIONS', '{{baseUrl}}/sun_positions');
xhr.send(data);import axios from 'axios';
const options = {method: 'OPTIONS', url: '{{baseUrl}}/sun_positions'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/sun_positions';
const options = {method: 'OPTIONS'};
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}}/sun_positions',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/sun_positions")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/sun_positions',
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: 'OPTIONS', url: '{{baseUrl}}/sun_positions'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/sun_positions');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'OPTIONS', url: '{{baseUrl}}/sun_positions'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/sun_positions';
const options = {method: 'OPTIONS'};
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}}/sun_positions"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/sun_positions" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/sun_positions",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/sun_positions');
echo $response->getBody();setUrl('{{baseUrl}}/sun_positions');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/sun_positions');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/sun_positions' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/sun_positions' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/sun_positions")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/sun_positions"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/sun_positions"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/sun_positions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/sun_positions') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/sun_positions";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/sun_positionshttp OPTIONS {{baseUrl}}/sun_positionswget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/sun_positionsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/sun_positions")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()
OPTIONS
CORS support (8)
{{baseUrl}}/timezone
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/timezone");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/timezone")require "http/client"
url = "{{baseUrl}}/timezone"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/timezone"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/timezone");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/timezone"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/timezone HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/timezone")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/timezone"))
.method("OPTIONS", 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}}/timezone")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/timezone")
.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('OPTIONS', '{{baseUrl}}/timezone');
xhr.send(data);import axios from 'axios';
const options = {method: 'OPTIONS', url: '{{baseUrl}}/timezone'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/timezone';
const options = {method: 'OPTIONS'};
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}}/timezone',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/timezone")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/timezone',
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: 'OPTIONS', url: '{{baseUrl}}/timezone'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/timezone');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'OPTIONS', url: '{{baseUrl}}/timezone'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/timezone';
const options = {method: 'OPTIONS'};
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}}/timezone"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/timezone" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/timezone",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/timezone');
echo $response->getBody();setUrl('{{baseUrl}}/timezone');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/timezone');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/timezone' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/timezone' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/timezone")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/timezone"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/timezone"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/timezone")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/timezone') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/timezone";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/timezonehttp OPTIONS {{baseUrl}}/timezonewget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/timezoneimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/timezone")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()
OPTIONS
CORS support (OPTIONS)
{{baseUrl}}/cities/findcitiesfromlatlong
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/cities/findcitiesfromlatlong");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/cities/findcitiesfromlatlong")require "http/client"
url = "{{baseUrl}}/cities/findcitiesfromlatlong"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/cities/findcitiesfromlatlong"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/cities/findcitiesfromlatlong");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/cities/findcitiesfromlatlong"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/cities/findcitiesfromlatlong HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/cities/findcitiesfromlatlong")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/cities/findcitiesfromlatlong"))
.method("OPTIONS", 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}}/cities/findcitiesfromlatlong")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/cities/findcitiesfromlatlong")
.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('OPTIONS', '{{baseUrl}}/cities/findcitiesfromlatlong');
xhr.send(data);import axios from 'axios';
const options = {
method: 'OPTIONS',
url: '{{baseUrl}}/cities/findcitiesfromlatlong'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/cities/findcitiesfromlatlong';
const options = {method: 'OPTIONS'};
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}}/cities/findcitiesfromlatlong',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/cities/findcitiesfromlatlong")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/cities/findcitiesfromlatlong',
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: 'OPTIONS',
url: '{{baseUrl}}/cities/findcitiesfromlatlong'
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/cities/findcitiesfromlatlong');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'OPTIONS',
url: '{{baseUrl}}/cities/findcitiesfromlatlong'
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/cities/findcitiesfromlatlong';
const options = {method: 'OPTIONS'};
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}}/cities/findcitiesfromlatlong"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/cities/findcitiesfromlatlong" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/cities/findcitiesfromlatlong",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/cities/findcitiesfromlatlong');
echo $response->getBody();setUrl('{{baseUrl}}/cities/findcitiesfromlatlong');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/cities/findcitiesfromlatlong');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/cities/findcitiesfromlatlong' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/cities/findcitiesfromlatlong' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/cities/findcitiesfromlatlong")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/cities/findcitiesfromlatlong"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/cities/findcitiesfromlatlong"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/cities/findcitiesfromlatlong")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/cities/findcitiesfromlatlong') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/cities/findcitiesfromlatlong";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/cities/findcitiesfromlatlonghttp OPTIONS {{baseUrl}}/cities/findcitiesfromlatlongwget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/cities/findcitiesfromlatlongimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cities/findcitiesfromlatlong")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()
OPTIONS
CORS support
{{baseUrl}}/airports
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/airports");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/options "{{baseUrl}}/airports")require "http/client"
url = "{{baseUrl}}/airports"
response = HTTP::Client.options url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Options,
RequestUri = new Uri("{{baseUrl}}/airports"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/airports");
var request = new RestRequest("", Method.Options);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/airports"
req, _ := http.NewRequest("OPTIONS", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}OPTIONS /baseUrl/airports HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("OPTIONS", "{{baseUrl}}/airports")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/airports"))
.method("OPTIONS", 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}}/airports")
.method("OPTIONS", null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.options("{{baseUrl}}/airports")
.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('OPTIONS', '{{baseUrl}}/airports');
xhr.send(data);import axios from 'axios';
const options = {method: 'OPTIONS', url: '{{baseUrl}}/airports'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/airports';
const options = {method: 'OPTIONS'};
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}}/airports',
method: 'OPTIONS',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/airports")
.method("OPTIONS", null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'OPTIONS',
hostname: 'example.com',
port: null,
path: '/baseUrl/airports',
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: 'OPTIONS', url: '{{baseUrl}}/airports'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('OPTIONS', '{{baseUrl}}/airports');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'OPTIONS', url: '{{baseUrl}}/airports'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/airports';
const options = {method: 'OPTIONS'};
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}}/airports"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"OPTIONS"];
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}}/airports" in
Client.call `OPTIONS uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/airports",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "OPTIONS",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('OPTIONS', '{{baseUrl}}/airports');
echo $response->getBody();setUrl('{{baseUrl}}/airports');
$request->setMethod(HTTP_METH_OPTIONS);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/airports');
$request->setRequestMethod('OPTIONS');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/airports' -Method OPTIONS $response = Invoke-RestMethod -Uri '{{baseUrl}}/airports' -Method OPTIONS import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("OPTIONS", "/baseUrl/airports")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/airports"
response = requests.options(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/airports"
response <- VERB("OPTIONS", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/airports")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Options.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.options('/baseUrl/airports') do |req|
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/airports";
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("OPTIONS").unwrap(), url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request OPTIONS \
--url {{baseUrl}}/airportshttp OPTIONS {{baseUrl}}/airportswget --quiet \
--method OPTIONS \
--output-document \
- {{baseUrl}}/airportsimport Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/airports")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "OPTIONS"
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()