Oxford Dictionaries
GET
Apply filters to response
{{baseUrl}}/entries/:source_lang/:word_id/:filters
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
word_id
filters
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/entries/:source_lang/:word_id/:filters");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/entries/:source_lang/:word_id/:filters" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/entries/:source_lang/:word_id/:filters"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/entries/:source_lang/:word_id/:filters"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/entries/:source_lang/:word_id/:filters");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/entries/:source_lang/:word_id/:filters"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/entries/:source_lang/:word_id/:filters HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/entries/:source_lang/:word_id/:filters")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/entries/:source_lang/:word_id/:filters"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/:filters")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/entries/:source_lang/:word_id/:filters")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/entries/:source_lang/:word_id/:filters');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/:filters',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/entries/:source_lang/:word_id/:filters';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/entries/:source_lang/:word_id/:filters',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/:filters")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/entries/:source_lang/:word_id/:filters',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/:filters',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/entries/:source_lang/:word_id/:filters');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/:filters',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/entries/:source_lang/:word_id/:filters';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/entries/:source_lang/:word_id/:filters"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/entries/:source_lang/:word_id/:filters" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/entries/:source_lang/:word_id/:filters",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/entries/:source_lang/:word_id/:filters', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/entries/:source_lang/:word_id/:filters');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/entries/:source_lang/:word_id/:filters');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/entries/:source_lang/:word_id/:filters' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/entries/:source_lang/:word_id/:filters' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/entries/:source_lang/:word_id/:filters", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/entries/:source_lang/:word_id/:filters"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/entries/:source_lang/:word_id/:filters"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/entries/:source_lang/:word_id/:filters")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/entries/:source_lang/:word_id/:filters') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/entries/:source_lang/:word_id/:filters";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/entries/:source_lang/:word_id/:filters \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/entries/:source_lang/:word_id/:filters \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/entries/:source_lang/:word_id/:filtersimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/entries/:source_lang/:word_id/:filters")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve dictionary information for a given word
{{baseUrl}}/entries/:source_lang/:word_id
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
word_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/entries/:source_lang/:word_id");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/entries/:source_lang/:word_id" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/entries/:source_lang/:word_id"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/entries/:source_lang/:word_id"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/entries/:source_lang/:word_id");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/entries/:source_lang/:word_id"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/entries/:source_lang/:word_id HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/entries/:source_lang/:word_id")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/entries/:source_lang/:word_id"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/entries/:source_lang/:word_id")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/entries/:source_lang/:word_id');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/entries/:source_lang/:word_id';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/entries/:source_lang/:word_id',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/entries/:source_lang/:word_id',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/entries/:source_lang/:word_id');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/entries/:source_lang/:word_id';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/entries/:source_lang/:word_id"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/entries/:source_lang/:word_id" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/entries/:source_lang/:word_id",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/entries/:source_lang/:word_id', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/entries/:source_lang/:word_id');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/entries/:source_lang/:word_id');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/entries/:source_lang/:word_id' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/entries/:source_lang/:word_id' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/entries/:source_lang/:word_id", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/entries/:source_lang/:word_id"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/entries/:source_lang/:word_id"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/entries/:source_lang/:word_id")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/entries/:source_lang/:word_id') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/entries/:source_lang/:word_id";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/entries/:source_lang/:word_id \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/entries/:source_lang/:word_id \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/entries/:source_lang/:word_idimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/entries/:source_lang/:word_id")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Specify GB or US dictionary for English entry search
{{baseUrl}}/entries/:source_lang/:word_id/regions=:region
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
word_id
region
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/entries/:source_lang/:word_id/regions=:region"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/entries/:source_lang/:word_id/regions=:region");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/entries/:source_lang/:word_id/regions=:region HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/entries/:source_lang/:word_id/regions=:region"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/regions=:region")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/entries/:source_lang/:word_id/regions=:region")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/regions=:region")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/entries/:source_lang/:word_id/regions=:region',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/entries/:source_lang/:word_id/regions=:region"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/entries/:source_lang/:word_id/regions=:region');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/entries/:source_lang/:word_id/regions=:region');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/entries/:source_lang/:word_id/regions=:region' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/entries/:source_lang/:word_id/regions=:region", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/entries/:source_lang/:word_id/regions=:region")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/entries/:source_lang/:word_id/regions=:region') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/entries/:source_lang/:word_id/regions=:region \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/entries/:source_lang/:word_id/regions=:region \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/entries/:source_lang/:word_id/regions=:regionimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/entries/:source_lang/:word_id/regions=:region")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Check a word exists in the dictionary and retrieve its root form
{{baseUrl}}/inflections/:source_lang/:word_id/:filters
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
filters
word_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/inflections/:source_lang/:word_id/:filters");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/inflections/:source_lang/:word_id/:filters" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/inflections/:source_lang/:word_id/:filters"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/inflections/:source_lang/:word_id/:filters"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/inflections/:source_lang/:word_id/:filters");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/inflections/:source_lang/:word_id/:filters"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/inflections/:source_lang/:word_id/:filters HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/inflections/:source_lang/:word_id/:filters")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/inflections/:source_lang/:word_id/:filters"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/inflections/:source_lang/:word_id/:filters")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/inflections/:source_lang/:word_id/:filters")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/inflections/:source_lang/:word_id/:filters');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/inflections/:source_lang/:word_id/:filters',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/inflections/:source_lang/:word_id/:filters';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/inflections/:source_lang/:word_id/:filters',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/inflections/:source_lang/:word_id/:filters")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/inflections/:source_lang/:word_id/:filters',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/inflections/:source_lang/:word_id/:filters',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/inflections/:source_lang/:word_id/:filters');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/inflections/:source_lang/:word_id/:filters',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/inflections/:source_lang/:word_id/:filters';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/inflections/:source_lang/:word_id/:filters"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/inflections/:source_lang/:word_id/:filters" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/inflections/:source_lang/:word_id/:filters",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/inflections/:source_lang/:word_id/:filters', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/inflections/:source_lang/:word_id/:filters');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/inflections/:source_lang/:word_id/:filters');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/inflections/:source_lang/:word_id/:filters' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/inflections/:source_lang/:word_id/:filters' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/inflections/:source_lang/:word_id/:filters", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/inflections/:source_lang/:word_id/:filters"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/inflections/:source_lang/:word_id/:filters"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/inflections/:source_lang/:word_id/:filters")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/inflections/:source_lang/:word_id/:filters') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/inflections/:source_lang/:word_id/:filters";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/inflections/:source_lang/:word_id/:filters \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/inflections/:source_lang/:word_id/:filters \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/inflections/:source_lang/:word_id/:filtersimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/inflections/:source_lang/:word_id/:filters")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve a list of frequencies of a word-words derived from a corpus.
{{baseUrl}}/stats/frequency/words/:source_lang/
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/frequency/words/:source_lang/");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/frequency/words/:source_lang/" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/stats/frequency/words/:source_lang/"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/frequency/words/:source_lang/"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/frequency/words/:source_lang/");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/frequency/words/:source_lang/"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/frequency/words/:source_lang/ HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/frequency/words/:source_lang/")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/frequency/words/:source_lang/"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/frequency/words/:source_lang/")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/frequency/words/:source_lang/")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/frequency/words/:source_lang/');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/frequency/words/:source_lang/',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/frequency/words/:source_lang/';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/frequency/words/:source_lang/',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/frequency/words/:source_lang/")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/frequency/words/:source_lang/',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/frequency/words/:source_lang/',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/frequency/words/:source_lang/');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/frequency/words/:source_lang/',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/frequency/words/:source_lang/';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/frequency/words/:source_lang/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/frequency/words/:source_lang/" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/frequency/words/:source_lang/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/frequency/words/:source_lang/', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/frequency/words/:source_lang/');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/frequency/words/:source_lang/');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/frequency/words/:source_lang/' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/frequency/words/:source_lang/' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/stats/frequency/words/:source_lang/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/frequency/words/:source_lang/"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/frequency/words/:source_lang/"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/frequency/words/:source_lang/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/frequency/words/:source_lang/') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/frequency/words/:source_lang/";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/frequency/words/:source_lang/ \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/stats/frequency/words/:source_lang/ \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/stats/frequency/words/:source_lang/import Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/frequency/words/:source_lang/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the frequency of a word derived from a corpus.
{{baseUrl}}/stats/frequency/word/:source_lang/
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/frequency/word/:source_lang/");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/frequency/word/:source_lang/" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/stats/frequency/word/:source_lang/"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/frequency/word/:source_lang/"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/frequency/word/:source_lang/");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/frequency/word/:source_lang/"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/frequency/word/:source_lang/ HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/frequency/word/:source_lang/")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/frequency/word/:source_lang/"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/frequency/word/:source_lang/")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/frequency/word/:source_lang/")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/frequency/word/:source_lang/');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/frequency/word/:source_lang/',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/frequency/word/:source_lang/';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/frequency/word/:source_lang/',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/frequency/word/:source_lang/")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/frequency/word/:source_lang/',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/frequency/word/:source_lang/',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/frequency/word/:source_lang/');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/frequency/word/:source_lang/',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/frequency/word/:source_lang/';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/frequency/word/:source_lang/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/frequency/word/:source_lang/" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/frequency/word/:source_lang/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/frequency/word/:source_lang/', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/frequency/word/:source_lang/');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/frequency/word/:source_lang/');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/frequency/word/:source_lang/' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/frequency/word/:source_lang/' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/stats/frequency/word/:source_lang/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/frequency/word/:source_lang/"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/frequency/word/:source_lang/"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/frequency/word/:source_lang/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/frequency/word/:source_lang/') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/frequency/word/:source_lang/";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/frequency/word/:source_lang/ \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/stats/frequency/word/:source_lang/ \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/stats/frequency/word/:source_lang/import Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/frequency/word/:source_lang/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve the frequency of ngrams (1-4) derived from a corpus
{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
corpus
ngram-size
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/ HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/ \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/ \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/import Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/stats/frequency/ngrams/:source_lang/:corpus/:ngram-size/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve possible matches to input
{{baseUrl}}/search/:source_lang
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/search/:source_lang");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/search/:source_lang" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/search/:source_lang"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/search/:source_lang"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/search/:source_lang");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/search/:source_lang"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/search/:source_lang HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/search/:source_lang")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/search/:source_lang"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/search/:source_lang")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/search/:source_lang")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/search/:source_lang');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/search/:source_lang',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/search/:source_lang';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/search/:source_lang',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/search/:source_lang")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/search/:source_lang',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/search/:source_lang',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/search/:source_lang');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/search/:source_lang',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/search/:source_lang';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/search/:source_lang"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/search/:source_lang" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/search/:source_lang",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/search/:source_lang', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/search/:source_lang');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/search/:source_lang');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/search/:source_lang' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/search/:source_lang' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/search/:source_lang", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/search/:source_lang"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/search/:source_lang"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/search/:source_lang")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/search/:source_lang') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/search/:source_lang";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/search/:source_lang \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/search/:source_lang \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/search/:source_langimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/search/:source_lang")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve possible translation matches to input
{{baseUrl}}/search/:source_search_language/translations=:target_search_language
HEADERS
app_id
app_key
QUERY PARAMS
source_search_language
target_search_language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/search/:source_search_language/translations=:target_search_language");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/search/:source_search_language/translations=:target_search_language" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/search/:source_search_language/translations=:target_search_language"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/search/:source_search_language/translations=:target_search_language"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/search/:source_search_language/translations=:target_search_language");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/search/:source_search_language/translations=:target_search_language"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/search/:source_search_language/translations=:target_search_language HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/search/:source_search_language/translations=:target_search_language")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/search/:source_search_language/translations=:target_search_language"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/search/:source_search_language/translations=:target_search_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/search/:source_search_language/translations=:target_search_language")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/search/:source_search_language/translations=:target_search_language');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/search/:source_search_language/translations=:target_search_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/search/:source_search_language/translations=:target_search_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/search/:source_search_language/translations=:target_search_language',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/search/:source_search_language/translations=:target_search_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/search/:source_search_language/translations=:target_search_language',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/search/:source_search_language/translations=:target_search_language',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/search/:source_search_language/translations=:target_search_language');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/search/:source_search_language/translations=:target_search_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/search/:source_search_language/translations=:target_search_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/search/:source_search_language/translations=:target_search_language"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/search/:source_search_language/translations=:target_search_language" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/search/:source_search_language/translations=:target_search_language",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/search/:source_search_language/translations=:target_search_language', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/search/:source_search_language/translations=:target_search_language');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/search/:source_search_language/translations=:target_search_language');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/search/:source_search_language/translations=:target_search_language' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/search/:source_search_language/translations=:target_search_language' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/search/:source_search_language/translations=:target_search_language", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/search/:source_search_language/translations=:target_search_language"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/search/:source_search_language/translations=:target_search_language"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/search/:source_search_language/translations=:target_search_language")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/search/:source_search_language/translations=:target_search_language') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/search/:source_search_language/translations=:target_search_language";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/search/:source_search_language/translations=:target_search_language \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/search/:source_search_language/translations=:target_search_language \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/search/:source_search_language/translations=:target_search_languageimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/search/:source_search_language/translations=:target_search_language")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve corpus sentences for a given word
{{baseUrl}}/entries/:source_language/:word_id/sentences
HEADERS
app_id
app_key
QUERY PARAMS
source_language
word_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/entries/:source_language/:word_id/sentences");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/entries/:source_language/:word_id/sentences" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/entries/:source_language/:word_id/sentences"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/entries/:source_language/:word_id/sentences"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/entries/:source_language/:word_id/sentences");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/entries/:source_language/:word_id/sentences"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/entries/:source_language/:word_id/sentences HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/entries/:source_language/:word_id/sentences")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/entries/:source_language/:word_id/sentences"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/entries/:source_language/:word_id/sentences")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/entries/:source_language/:word_id/sentences")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/entries/:source_language/:word_id/sentences');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_language/:word_id/sentences',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/entries/:source_language/:word_id/sentences';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/entries/:source_language/:word_id/sentences',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/entries/:source_language/:word_id/sentences")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/entries/:source_language/:word_id/sentences',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_language/:word_id/sentences',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/entries/:source_language/:word_id/sentences');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_language/:word_id/sentences',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/entries/:source_language/:word_id/sentences';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/entries/:source_language/:word_id/sentences"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/entries/:source_language/:word_id/sentences" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/entries/:source_language/:word_id/sentences",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/entries/:source_language/:word_id/sentences', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/entries/:source_language/:word_id/sentences');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/entries/:source_language/:word_id/sentences');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/entries/:source_language/:word_id/sentences' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/entries/:source_language/:word_id/sentences' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/entries/:source_language/:word_id/sentences", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/entries/:source_language/:word_id/sentences"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/entries/:source_language/:word_id/sentences"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/entries/:source_language/:word_id/sentences")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/entries/:source_language/:word_id/sentences') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/entries/:source_language/:word_id/sentences";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/entries/:source_language/:word_id/sentences \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/entries/:source_language/:word_id/sentences \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/entries/:source_language/:word_id/sentencesimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/entries/:source_language/:word_id/sentences")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve synonyms and antonyms for a given word
{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
word_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/entries/:source_lang/:word_id/synonyms;antonyms HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/entries/:source_lang/:word_id/synonyms;antonyms',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/entries/:source_lang/:word_id/synonyms;antonyms", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/entries/:source_lang/:word_id/synonyms;antonyms') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms' \
--header 'app_id: ' \
--header 'app_key: 'http GET '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms' \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- '{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms'import Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/entries/:source_lang/:word_id/synonyms;antonyms")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve words that are similar
{{baseUrl}}/entries/:source_lang/:word_id/synonyms
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
word_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/entries/:source_lang/:word_id/synonyms");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/entries/:source_lang/:word_id/synonyms" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/entries/:source_lang/:word_id/synonyms"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/entries/:source_lang/:word_id/synonyms"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/entries/:source_lang/:word_id/synonyms");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/entries/:source_lang/:word_id/synonyms"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/entries/:source_lang/:word_id/synonyms HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/entries/:source_lang/:word_id/synonyms")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/entries/:source_lang/:word_id/synonyms"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/synonyms")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/entries/:source_lang/:word_id/synonyms")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/entries/:source_lang/:word_id/synonyms');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/synonyms',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/entries/:source_lang/:word_id/synonyms';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/entries/:source_lang/:word_id/synonyms',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/synonyms")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/entries/:source_lang/:word_id/synonyms',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/synonyms',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/entries/:source_lang/:word_id/synonyms');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/synonyms',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/entries/:source_lang/:word_id/synonyms';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/entries/:source_lang/:word_id/synonyms"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/entries/:source_lang/:word_id/synonyms" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/entries/:source_lang/:word_id/synonyms",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/entries/:source_lang/:word_id/synonyms', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/entries/:source_lang/:word_id/synonyms');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/entries/:source_lang/:word_id/synonyms');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/entries/:source_lang/:word_id/synonyms' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/entries/:source_lang/:word_id/synonyms' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/entries/:source_lang/:word_id/synonyms", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/entries/:source_lang/:word_id/synonyms"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/entries/:source_lang/:word_id/synonyms"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/entries/:source_lang/:word_id/synonyms")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/entries/:source_lang/:word_id/synonyms') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/entries/:source_lang/:word_id/synonyms";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/entries/:source_lang/:word_id/synonyms \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/entries/:source_lang/:word_id/synonyms \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/entries/:source_lang/:word_id/synonymsimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/entries/:source_lang/:word_id/synonyms")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve words that mean the opposite
{{baseUrl}}/entries/:source_lang/:word_id/antonyms
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
word_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/entries/:source_lang/:word_id/antonyms");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/entries/:source_lang/:word_id/antonyms" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/entries/:source_lang/:word_id/antonyms"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/entries/:source_lang/:word_id/antonyms"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/entries/:source_lang/:word_id/antonyms");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/entries/:source_lang/:word_id/antonyms"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/entries/:source_lang/:word_id/antonyms HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/entries/:source_lang/:word_id/antonyms")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/entries/:source_lang/:word_id/antonyms"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/antonyms")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/entries/:source_lang/:word_id/antonyms")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/entries/:source_lang/:word_id/antonyms');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/antonyms',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/entries/:source_lang/:word_id/antonyms';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/entries/:source_lang/:word_id/antonyms',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/entries/:source_lang/:word_id/antonyms")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/entries/:source_lang/:word_id/antonyms',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/antonyms',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/entries/:source_lang/:word_id/antonyms');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_lang/:word_id/antonyms',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/entries/:source_lang/:word_id/antonyms';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/entries/:source_lang/:word_id/antonyms"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/entries/:source_lang/:word_id/antonyms" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/entries/:source_lang/:word_id/antonyms",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/entries/:source_lang/:word_id/antonyms', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/entries/:source_lang/:word_id/antonyms');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/entries/:source_lang/:word_id/antonyms');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/entries/:source_lang/:word_id/antonyms' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/entries/:source_lang/:word_id/antonyms' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/entries/:source_lang/:word_id/antonyms", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/entries/:source_lang/:word_id/antonyms"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/entries/:source_lang/:word_id/antonyms"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/entries/:source_lang/:word_id/antonyms")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/entries/:source_lang/:word_id/antonyms') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/entries/:source_lang/:word_id/antonyms";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/entries/:source_lang/:word_id/antonyms \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/entries/:source_lang/:word_id/antonyms \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/entries/:source_lang/:word_id/antonymsimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/entries/:source_lang/:word_id/antonyms")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve translation for a given word
{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language
HEADERS
app_id
app_key
QUERY PARAMS
source_translation_language
word_id
target_translation_language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/entries/:source_translation_language/:word_id/translations=:target_translation_language HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/entries/:source_translation_language/:word_id/translations=:target_translation_language',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/entries/:source_translation_language/:word_id/translations=:target_translation_language", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/entries/:source_translation_language/:word_id/translations=:target_translation_language') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_languageimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/entries/:source_translation_language/:word_id/translations=:target_translation_language")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available dictionaries
{{baseUrl}}/languages
HEADERS
app_id
app_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/languages");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/languages" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/languages"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/languages"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/languages");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/languages"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/languages HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/languages")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/languages"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/languages")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/languages")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/languages');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/languages',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/languages';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/languages',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/languages")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/languages',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/languages',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/languages');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/languages',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/languages';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/languages"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/languages" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/languages",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/languages', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/languages');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/languages');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/languages' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/languages' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/languages", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/languages"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/languages"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/languages")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/languages') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/languages";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/languages \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/languages \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/languagesimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/languages")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available domains in a bilingual dataset
{{baseUrl}}/domains/:source_domains_language/:target_domains_language
HEADERS
app_id
app_key
QUERY PARAMS
source_domains_language
target_domains_language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:source_domains_language/:target_domains_language");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/domains/:source_domains_language/:target_domains_language" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/domains/:source_domains_language/:target_domains_language"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/domains/:source_domains_language/:target_domains_language"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/domains/:source_domains_language/:target_domains_language");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/domains/:source_domains_language/:target_domains_language"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/domains/:source_domains_language/:target_domains_language HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:source_domains_language/:target_domains_language")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/domains/:source_domains_language/:target_domains_language"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/domains/:source_domains_language/:target_domains_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/domains/:source_domains_language/:target_domains_language")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/domains/:source_domains_language/:target_domains_language');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/domains/:source_domains_language/:target_domains_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/domains/:source_domains_language/:target_domains_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/domains/:source_domains_language/:target_domains_language',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/domains/:source_domains_language/:target_domains_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/domains/:source_domains_language/:target_domains_language',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/domains/:source_domains_language/:target_domains_language',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/domains/:source_domains_language/:target_domains_language');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/domains/:source_domains_language/:target_domains_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/domains/:source_domains_language/:target_domains_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:source_domains_language/:target_domains_language"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/domains/:source_domains_language/:target_domains_language" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/domains/:source_domains_language/:target_domains_language",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/domains/:source_domains_language/:target_domains_language', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/domains/:source_domains_language/:target_domains_language');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/domains/:source_domains_language/:target_domains_language');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:source_domains_language/:target_domains_language' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:source_domains_language/:target_domains_language' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/domains/:source_domains_language/:target_domains_language", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/domains/:source_domains_language/:target_domains_language"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/domains/:source_domains_language/:target_domains_language"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/domains/:source_domains_language/:target_domains_language")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/domains/:source_domains_language/:target_domains_language') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/domains/:source_domains_language/:target_domains_language";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/domains/:source_domains_language/:target_domains_language \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/domains/:source_domains_language/:target_domains_language \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/domains/:source_domains_language/:target_domains_languageimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:source_domains_language/:target_domains_language")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available domains in a monolingual dataset
{{baseUrl}}/domains/:source_language
HEADERS
app_id
app_key
QUERY PARAMS
source_language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/domains/:source_language");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/domains/:source_language" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/domains/:source_language"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/domains/:source_language"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/domains/:source_language");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/domains/:source_language"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/domains/:source_language HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/domains/:source_language")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/domains/:source_language"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/domains/:source_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/domains/:source_language")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/domains/:source_language');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/domains/:source_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/domains/:source_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/domains/:source_language',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/domains/:source_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/domains/:source_language',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/domains/:source_language',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/domains/:source_language');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/domains/:source_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/domains/:source_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/domains/:source_language"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/domains/:source_language" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/domains/:source_language",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/domains/:source_language', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/domains/:source_language');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/domains/:source_language');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/domains/:source_language' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/domains/:source_language' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/domains/:source_language", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/domains/:source_language"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/domains/:source_language"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/domains/:source_language")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/domains/:source_language') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/domains/:source_language";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/domains/:source_language \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/domains/:source_language \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/domains/:source_languageimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/domains/:source_language")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available filters for specific endpoint
{{baseUrl}}/filters/:endpoint
HEADERS
app_id
app_key
QUERY PARAMS
endpoint
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/filters/:endpoint");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/filters/:endpoint" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/filters/:endpoint"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/filters/:endpoint"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/filters/:endpoint");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/filters/:endpoint"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/filters/:endpoint HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/filters/:endpoint")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/filters/:endpoint"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/filters/:endpoint")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/filters/:endpoint")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/filters/:endpoint');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/filters/:endpoint',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/filters/:endpoint';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/filters/:endpoint',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/filters/:endpoint")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/filters/:endpoint',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/filters/:endpoint',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/filters/:endpoint');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/filters/:endpoint',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/filters/:endpoint';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/filters/:endpoint"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/filters/:endpoint" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/filters/:endpoint",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/filters/:endpoint', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/filters/:endpoint');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/filters/:endpoint');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/filters/:endpoint' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/filters/:endpoint' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/filters/:endpoint", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/filters/:endpoint"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/filters/:endpoint"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/filters/:endpoint")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/filters/:endpoint') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/filters/:endpoint";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/filters/:endpoint \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/filters/:endpoint \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/filters/:endpointimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/filters/:endpoint")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available filters
{{baseUrl}}/filters
HEADERS
app_id
app_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/filters");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/filters" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/filters"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/filters"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/filters");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/filters"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/filters HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/filters")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/filters"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/filters")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/filters")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/filters');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/filters',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/filters';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/filters',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/filters")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/filters',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/filters',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/filters');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/filters',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/filters';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/filters"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/filters" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/filters",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/filters', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/filters');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/filters');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/filters' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/filters' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/filters", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/filters"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/filters"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/filters")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/filters') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/filters";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/filters \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/filters \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/filtersimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/filters")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available grammatical features in a dataset
{{baseUrl}}/grammaticalFeatures/:source_language
HEADERS
app_id
app_key
QUERY PARAMS
source_language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/grammaticalFeatures/:source_language");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/grammaticalFeatures/:source_language" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/grammaticalFeatures/:source_language"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/grammaticalFeatures/:source_language"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/grammaticalFeatures/:source_language");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/grammaticalFeatures/:source_language"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/grammaticalFeatures/:source_language HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/grammaticalFeatures/:source_language")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/grammaticalFeatures/:source_language"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/grammaticalFeatures/:source_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/grammaticalFeatures/:source_language")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/grammaticalFeatures/:source_language');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/grammaticalFeatures/:source_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/grammaticalFeatures/:source_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/grammaticalFeatures/:source_language',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/grammaticalFeatures/:source_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/grammaticalFeatures/:source_language',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/grammaticalFeatures/:source_language',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/grammaticalFeatures/:source_language');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/grammaticalFeatures/:source_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/grammaticalFeatures/:source_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/grammaticalFeatures/:source_language"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/grammaticalFeatures/:source_language" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/grammaticalFeatures/:source_language",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/grammaticalFeatures/:source_language', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/grammaticalFeatures/:source_language');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/grammaticalFeatures/:source_language');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/grammaticalFeatures/:source_language' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/grammaticalFeatures/:source_language' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/grammaticalFeatures/:source_language", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/grammaticalFeatures/:source_language"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/grammaticalFeatures/:source_language"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/grammaticalFeatures/:source_language")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/grammaticalFeatures/:source_language') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/grammaticalFeatures/:source_language";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/grammaticalFeatures/:source_language \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/grammaticalFeatures/:source_language \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/grammaticalFeatures/:source_languageimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/grammaticalFeatures/:source_language")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available lexical categories in a dataset
{{baseUrl}}/lexicalcategories/:language
HEADERS
app_id
app_key
QUERY PARAMS
language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/lexicalcategories/:language");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/lexicalcategories/:language" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/lexicalcategories/:language"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/lexicalcategories/:language"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/lexicalcategories/:language");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/lexicalcategories/:language"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/lexicalcategories/:language HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/lexicalcategories/:language")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/lexicalcategories/:language"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/lexicalcategories/:language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/lexicalcategories/:language")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/lexicalcategories/:language');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/lexicalcategories/:language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/lexicalcategories/:language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/lexicalcategories/:language',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/lexicalcategories/:language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/lexicalcategories/:language',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/lexicalcategories/:language',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/lexicalcategories/:language');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/lexicalcategories/:language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/lexicalcategories/:language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/lexicalcategories/:language"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/lexicalcategories/:language" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/lexicalcategories/:language",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/lexicalcategories/:language', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/lexicalcategories/:language');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/lexicalcategories/:language');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/lexicalcategories/:language' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/lexicalcategories/:language' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/lexicalcategories/:language", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/lexicalcategories/:language"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/lexicalcategories/:language"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/lexicalcategories/:language")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/lexicalcategories/:language') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/lexicalcategories/:language";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/lexicalcategories/:language \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/lexicalcategories/:language \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/lexicalcategories/:languageimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/lexicalcategories/:language")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available regions in a monolingual dataset
{{baseUrl}}/regions/:source_language
HEADERS
app_id
app_key
QUERY PARAMS
source_language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/regions/:source_language");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/regions/:source_language" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/regions/:source_language"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/regions/:source_language"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/regions/:source_language");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/regions/:source_language"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/regions/:source_language HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/regions/:source_language")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/regions/:source_language"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/regions/:source_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/regions/:source_language")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/regions/:source_language');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/regions/:source_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/regions/:source_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/regions/:source_language',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/regions/:source_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/regions/:source_language',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/regions/:source_language',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/regions/:source_language');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/regions/:source_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/regions/:source_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/regions/:source_language"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/regions/:source_language" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/regions/:source_language",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/regions/:source_language', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/regions/:source_language');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/regions/:source_language');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/regions/:source_language' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/regions/:source_language' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/regions/:source_language", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/regions/:source_language"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/regions/:source_language"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/regions/:source_language")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/regions/:source_language') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/regions/:source_language";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/regions/:source_language \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/regions/:source_language \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/regions/:source_languageimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/regions/:source_language")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available registers in a bilingual dataset
{{baseUrl}}/registers/:source_register_language/:target_register_language
HEADERS
app_id
app_key
QUERY PARAMS
source_register_language
target_register_language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/registers/:source_register_language/:target_register_language");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/registers/:source_register_language/:target_register_language" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/registers/:source_register_language/:target_register_language"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/registers/:source_register_language/:target_register_language"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/registers/:source_register_language/:target_register_language");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/registers/:source_register_language/:target_register_language"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/registers/:source_register_language/:target_register_language HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/registers/:source_register_language/:target_register_language")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/registers/:source_register_language/:target_register_language"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/registers/:source_register_language/:target_register_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/registers/:source_register_language/:target_register_language")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/registers/:source_register_language/:target_register_language');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/registers/:source_register_language/:target_register_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/registers/:source_register_language/:target_register_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/registers/:source_register_language/:target_register_language',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/registers/:source_register_language/:target_register_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/registers/:source_register_language/:target_register_language',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/registers/:source_register_language/:target_register_language',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/registers/:source_register_language/:target_register_language');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/registers/:source_register_language/:target_register_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/registers/:source_register_language/:target_register_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/registers/:source_register_language/:target_register_language"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/registers/:source_register_language/:target_register_language" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/registers/:source_register_language/:target_register_language",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/registers/:source_register_language/:target_register_language', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/registers/:source_register_language/:target_register_language');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/registers/:source_register_language/:target_register_language');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/registers/:source_register_language/:target_register_language' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/registers/:source_register_language/:target_register_language' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/registers/:source_register_language/:target_register_language", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/registers/:source_register_language/:target_register_language"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/registers/:source_register_language/:target_register_language"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/registers/:source_register_language/:target_register_language")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/registers/:source_register_language/:target_register_language') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/registers/:source_register_language/:target_register_language";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/registers/:source_register_language/:target_register_language \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/registers/:source_register_language/:target_register_language \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/registers/:source_register_language/:target_register_languageimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/registers/:source_register_language/:target_register_language")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Lists available registers in a monolingual dataset
{{baseUrl}}/registers/:source_language
HEADERS
app_id
app_key
QUERY PARAMS
source_language
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/registers/:source_language");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/registers/:source_language" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/registers/:source_language"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/registers/:source_language"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/registers/:source_language");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/registers/:source_language"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/registers/:source_language HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/registers/:source_language")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/registers/:source_language"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/registers/:source_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/registers/:source_language")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/registers/:source_language');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/registers/:source_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/registers/:source_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/registers/:source_language',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/registers/:source_language")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/registers/:source_language',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/registers/:source_language',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/registers/:source_language');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/registers/:source_language',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/registers/:source_language';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/registers/:source_language"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/registers/:source_language" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/registers/:source_language",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/registers/:source_language', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/registers/:source_language');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/registers/:source_language');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/registers/:source_language' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/registers/:source_language' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/registers/:source_language", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/registers/:source_language"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/registers/:source_language"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/registers/:source_language")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/registers/:source_language') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/registers/:source_language";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/registers/:source_language \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/registers/:source_language \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/registers/:source_languageimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/registers/:source_language")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve a list of words in a category
{{baseUrl}}/wordlist/:source_lang/:filters_basic
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
filters_basic
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wordlist/:source_lang/:filters_basic");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/wordlist/:source_lang/:filters_basic" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/wordlist/:source_lang/:filters_basic"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/wordlist/:source_lang/:filters_basic"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/wordlist/:source_lang/:filters_basic");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/wordlist/:source_lang/:filters_basic"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/wordlist/:source_lang/:filters_basic HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/wordlist/:source_lang/:filters_basic")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/wordlist/:source_lang/:filters_basic"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/wordlist/:source_lang/:filters_basic")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/wordlist/:source_lang/:filters_basic")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/wordlist/:source_lang/:filters_basic');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/wordlist/:source_lang/:filters_basic',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/wordlist/:source_lang/:filters_basic';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/wordlist/:source_lang/:filters_basic',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/wordlist/:source_lang/:filters_basic")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/wordlist/:source_lang/:filters_basic',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/wordlist/:source_lang/:filters_basic',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/wordlist/:source_lang/:filters_basic');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/wordlist/:source_lang/:filters_basic',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/wordlist/:source_lang/:filters_basic';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wordlist/:source_lang/:filters_basic"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/wordlist/:source_lang/:filters_basic" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/wordlist/:source_lang/:filters_basic",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/wordlist/:source_lang/:filters_basic', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/wordlist/:source_lang/:filters_basic');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/wordlist/:source_lang/:filters_basic');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/wordlist/:source_lang/:filters_basic' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wordlist/:source_lang/:filters_basic' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/wordlist/:source_lang/:filters_basic", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/wordlist/:source_lang/:filters_basic"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/wordlist/:source_lang/:filters_basic"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/wordlist/:source_lang/:filters_basic")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/wordlist/:source_lang/:filters_basic') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/wordlist/:source_lang/:filters_basic";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/wordlist/:source_lang/:filters_basic \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/wordlist/:source_lang/:filters_basic \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/wordlist/:source_lang/:filters_basicimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wordlist/:source_lang/:filters_basic")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Retrieve list of words for category with advanced options
{{baseUrl}}/wordlist/:source_lang/:filters_advanced
HEADERS
app_id
app_key
QUERY PARAMS
source_lang
filters_advanced
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/wordlist/:source_lang/:filters_advanced");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "app_id: ");
headers = curl_slist_append(headers, "app_key: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/wordlist/:source_lang/:filters_advanced" {:headers {:app_id ""
:app_key ""}})require "http/client"
url = "{{baseUrl}}/wordlist/:source_lang/:filters_advanced"
headers = HTTP::Headers{
"app_id" => ""
"app_key" => ""
}
response = HTTP::Client.get url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri("{{baseUrl}}/wordlist/:source_lang/:filters_advanced"),
Headers =
{
{ "app_id", "" },
{ "app_key", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/wordlist/:source_lang/:filters_advanced");
var request = new RestRequest("", Method.Get);
request.AddHeader("app_id", "");
request.AddHeader("app_key", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/wordlist/:source_lang/:filters_advanced"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("app_id", "")
req.Header.Add("app_key", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/wordlist/:source_lang/:filters_advanced HTTP/1.1
App_id:
App_key:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/wordlist/:source_lang/:filters_advanced")
.setHeader("app_id", "")
.setHeader("app_key", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/wordlist/:source_lang/:filters_advanced"))
.header("app_id", "")
.header("app_key", "")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/wordlist/:source_lang/:filters_advanced")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/wordlist/:source_lang/:filters_advanced")
.header("app_id", "")
.header("app_key", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/wordlist/:source_lang/:filters_advanced');
xhr.setRequestHeader('app_id', '');
xhr.setRequestHeader('app_key', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/wordlist/:source_lang/:filters_advanced',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/wordlist/:source_lang/:filters_advanced';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/wordlist/:source_lang/:filters_advanced',
method: 'GET',
headers: {
app_id: '',
app_key: ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/wordlist/:source_lang/:filters_advanced")
.get()
.addHeader("app_id", "")
.addHeader("app_key", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/wordlist/:source_lang/:filters_advanced',
headers: {
app_id: '',
app_key: ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/wordlist/:source_lang/:filters_advanced',
headers: {app_id: '', app_key: ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/wordlist/:source_lang/:filters_advanced');
req.headers({
app_id: '',
app_key: ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/wordlist/:source_lang/:filters_advanced',
headers: {app_id: '', app_key: ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/wordlist/:source_lang/:filters_advanced';
const options = {method: 'GET', headers: {app_id: '', app_key: ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"app_id": @"",
@"app_key": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/wordlist/:source_lang/:filters_advanced"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/wordlist/:source_lang/:filters_advanced" in
let headers = Header.add_list (Header.init ()) [
("app_id", "");
("app_key", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/wordlist/:source_lang/:filters_advanced",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"app_id: ",
"app_key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/wordlist/:source_lang/:filters_advanced', [
'headers' => [
'app_id' => '',
'app_key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/wordlist/:source_lang/:filters_advanced');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/wordlist/:source_lang/:filters_advanced');
$request->setRequestMethod('GET');
$request->setHeaders([
'app_id' => '',
'app_key' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/wordlist/:source_lang/:filters_advanced' -Method GET -Headers $headers$headers=@{}
$headers.Add("app_id", "")
$headers.Add("app_key", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/wordlist/:source_lang/:filters_advanced' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'app_id': "",
'app_key': ""
}
conn.request("GET", "/baseUrl/wordlist/:source_lang/:filters_advanced", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/wordlist/:source_lang/:filters_advanced"
headers = {
"app_id": "",
"app_key": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/wordlist/:source_lang/:filters_advanced"
response <- VERB("GET", url, add_headers('app_id' = '', 'app_key' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/wordlist/:source_lang/:filters_advanced")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["app_id"] = ''
request["app_key"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/wordlist/:source_lang/:filters_advanced') do |req|
req.headers['app_id'] = ''
req.headers['app_key'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/wordlist/:source_lang/:filters_advanced";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("app_id", "".parse().unwrap());
headers.insert("app_key", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/wordlist/:source_lang/:filters_advanced \
--header 'app_id: ' \
--header 'app_key: 'http GET {{baseUrl}}/wordlist/:source_lang/:filters_advanced \
app_id:'' \
app_key:''wget --quiet \
--method GET \
--header 'app_id: ' \
--header 'app_key: ' \
--output-document \
- {{baseUrl}}/wordlist/:source_lang/:filters_advancedimport Foundation
let headers = [
"app_id": "",
"app_key": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/wordlist/:source_lang/:filters_advanced")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()