Gateway REST API
POST
Add a pre-specified -API token- with the -session object- defined in the body, this operatin creates a custom token that dsoes not use the gateway naming convention for tokens
{{baseUrl}}/tyk/keys/:keyId
HEADERS
x-tyk-authorization
QUERY PARAMS
keyId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/keys/:keyId");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/tyk/keys/:keyId" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/keys/:keyId"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/tyk/keys/:keyId"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/keys/:keyId");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/keys/:keyId"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/tyk/keys/:keyId HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tyk/keys/:keyId")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/keys/:keyId"))
.header("x-tyk-authorization", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/keys/:keyId")
.post(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/tyk/keys/:keyId")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/tyk/keys/:keyId');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/keys/:keyId',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/keys/:keyId';
const options = {method: 'POST', headers: {'x-tyk-authorization': ''}};
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}}/tyk/keys/:keyId',
method: 'POST',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/keys/:keyId")
.post(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/keys/:keyId',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/keys/:keyId',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/tyk/keys/:keyId');
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/keys/:keyId',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/keys/:keyId';
const options = {method: 'POST', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/keys/:keyId"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/keys/:keyId" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/keys/:keyId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/tyk/keys/:keyId', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/keys/:keyId');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/keys/:keyId');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/keys/:keyId' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/keys/:keyId' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("POST", "/baseUrl/tyk/keys/:keyId", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/keys/:keyId"
headers = {"x-tyk-authorization": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/keys/:keyId"
response <- VERB("POST", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/keys/:keyId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/tyk/keys/:keyId') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/keys/:keyId";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/tyk/keys/:keyId \
--header 'x-tyk-authorization: 'http POST {{baseUrl}}/tyk/keys/:keyId \
x-tyk-authorization:''wget --quiet \
--method POST \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/keys/:keyIdimport Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/keys/:keyId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a new -API token- with the -session object- defined in the body
{{baseUrl}}/tyk/keys/create
HEADERS
x-tyk-authorization
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/keys/create");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/tyk/keys/create" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/keys/create"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/tyk/keys/create"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/keys/create");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/keys/create"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/tyk/keys/create HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tyk/keys/create")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/keys/create"))
.header("x-tyk-authorization", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/keys/create")
.post(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/tyk/keys/create")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/tyk/keys/create');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/keys/create',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/keys/create';
const options = {method: 'POST', headers: {'x-tyk-authorization': ''}};
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}}/tyk/keys/create',
method: 'POST',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/keys/create")
.post(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/keys/create',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/keys/create',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/tyk/keys/create');
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/keys/create',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/keys/create';
const options = {method: 'POST', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/keys/create"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/keys/create" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/keys/create",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/tyk/keys/create', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/keys/create');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/keys/create');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/keys/create' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/keys/create' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("POST", "/baseUrl/tyk/keys/create", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/keys/create"
headers = {"x-tyk-authorization": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/keys/create"
response <- VERB("POST", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/keys/create")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/tyk/keys/create') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/keys/create";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/tyk/keys/create \
--header 'x-tyk-authorization: 'http POST {{baseUrl}}/tyk/keys/create \
x-tyk-authorization:''wget --quiet \
--method POST \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/keys/createimport Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/keys/create")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create a new OAuth client
{{baseUrl}}/tyk/oauth/clients/create
HEADERS
x-tyk-authorization
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/oauth/clients/create");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/tyk/oauth/clients/create" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/oauth/clients/create"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/tyk/oauth/clients/create"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/oauth/clients/create");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/oauth/clients/create"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/tyk/oauth/clients/create HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tyk/oauth/clients/create")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/oauth/clients/create"))
.header("x-tyk-authorization", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/oauth/clients/create")
.post(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/tyk/oauth/clients/create")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/tyk/oauth/clients/create');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/oauth/clients/create',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/oauth/clients/create';
const options = {method: 'POST', headers: {'x-tyk-authorization': ''}};
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}}/tyk/oauth/clients/create',
method: 'POST',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/oauth/clients/create")
.post(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/oauth/clients/create',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/oauth/clients/create',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/tyk/oauth/clients/create');
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/oauth/clients/create',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/oauth/clients/create';
const options = {method: 'POST', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/oauth/clients/create"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/oauth/clients/create" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/oauth/clients/create",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/tyk/oauth/clients/create', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/oauth/clients/create');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/oauth/clients/create');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/oauth/clients/create' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/oauth/clients/create' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("POST", "/baseUrl/tyk/oauth/clients/create", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/oauth/clients/create"
headers = {"x-tyk-authorization": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/oauth/clients/create"
response <- VERB("POST", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/oauth/clients/create")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/tyk/oauth/clients/create') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/oauth/clients/create";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/tyk/oauth/clients/create \
--header 'x-tyk-authorization: 'http POST {{baseUrl}}/tyk/oauth/clients/create \
x-tyk-authorization:''wget --quiet \
--method POST \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/oauth/clients/createimport Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/oauth/clients/create")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
Create an -API Definition- object
{{baseUrl}}/tyk/apis/
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/apis/");
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/tyk/apis/")require "http/client"
url = "{{baseUrl}}/tyk/apis/"
response = HTTP::Client.post url
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/tyk/apis/"),
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/apis/");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/apis/"
req, _ := http.NewRequest("POST", url, nil)
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/tyk/apis/ HTTP/1.1
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tyk/apis/")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/apis/"))
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/apis/")
.post(null)
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/tyk/apis/")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/tyk/apis/');
xhr.send(data);import axios from 'axios';
const options = {method: 'POST', url: '{{baseUrl}}/tyk/apis/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/apis/';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/tyk/apis/',
method: 'POST',
headers: {}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/apis/")
.post(null)
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/apis/',
headers: {}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {method: 'POST', url: '{{baseUrl}}/tyk/apis/'};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/tyk/apis/');
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {method: 'POST', url: '{{baseUrl}}/tyk/apis/'};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/apis/';
const options = {method: 'POST'};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/apis/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/apis/" in
Client.call `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/apis/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/tyk/apis/');
echo $response->getBody();setUrl('{{baseUrl}}/tyk/apis/');
$request->setMethod(HTTP_METH_POST);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/apis/');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/apis/' -Method POST $response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/apis/' -Method POST import http.client
conn = http.client.HTTPSConnection("example.com")
conn.request("POST", "/baseUrl/tyk/apis/")
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/apis/"
response = requests.post(url)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/apis/"
response <- VERB("POST", url, content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/apis/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/tyk/apis/') do |req|
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/apis/";
let client = reqwest::Client::new();
let response = client.post(url)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/tyk/apis/http POST {{baseUrl}}/tyk/apis/wget --quiet \
--method POST \
--output-document \
- {{baseUrl}}/tyk/apis/import Foundation
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/apis/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Delete the OAuth client
{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId
HEADERS
x-tyk-authorization
QUERY PARAMS
apiId
clientId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/tyk/oauth/clients/:apiId/:clientId HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId"))
.header("x-tyk-authorization", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId")
.delete(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId';
const options = {method: 'DELETE', headers: {'x-tyk-authorization': ''}};
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}}/tyk/oauth/clients/:apiId/:clientId',
method: 'DELETE',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId")
.delete(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/oauth/clients/:apiId/:clientId',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId');
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId';
const options = {method: 'DELETE', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("DELETE", "/baseUrl/tyk/oauth/clients/:apiId/:clientId", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId"
headers = {"x-tyk-authorization": ""}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId"
response <- VERB("DELETE", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/tyk/oauth/clients/:apiId/:clientId') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/tyk/oauth/clients/:apiId/:clientId \
--header 'x-tyk-authorization: 'http DELETE {{baseUrl}}/tyk/oauth/clients/:apiId/:clientId \
x-tyk-authorization:''wget --quiet \
--method DELETE \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/oauth/clients/:apiId/:clientIdimport Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/oauth/clients/:apiId/:clientId")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Deletes an -API Definition- object, if it exists
{{baseUrl}}/tyk/apis/:apiID
HEADERS
x-tyk-authorization
QUERY PARAMS
apiID
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/apis/:apiID");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/tyk/apis/:apiID" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/apis/:apiID"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/tyk/apis/:apiID"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/apis/:apiID");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/apis/:apiID"
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/tyk/apis/:apiID HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tyk/apis/:apiID")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/apis/:apiID"))
.header("x-tyk-authorization", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/apis/:apiID")
.delete(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/tyk/apis/:apiID")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/tyk/apis/:apiID');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/apis/:apiID',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/apis/:apiID';
const options = {method: 'DELETE', headers: {'x-tyk-authorization': ''}};
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}}/tyk/apis/:apiID',
method: 'DELETE',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/apis/:apiID")
.delete(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/apis/:apiID',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/apis/:apiID',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/tyk/apis/:apiID');
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/apis/:apiID',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/apis/:apiID';
const options = {method: 'DELETE', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/apis/:apiID"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/apis/:apiID" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/apis/:apiID",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/tyk/apis/:apiID', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/apis/:apiID');
$request->setMethod(HTTP_METH_DELETE);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/apis/:apiID');
$request->setRequestMethod('DELETE');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/apis/:apiID' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/apis/:apiID' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("DELETE", "/baseUrl/tyk/apis/:apiID", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/apis/:apiID"
headers = {"x-tyk-authorization": ""}
response = requests.delete(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/apis/:apiID"
response <- VERB("DELETE", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/apis/:apiID")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/tyk/apis/:apiID') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/apis/:apiID";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url {{baseUrl}}/tyk/apis/:apiID \
--header 'x-tyk-authorization: 'http DELETE {{baseUrl}}/tyk/apis/:apiID \
x-tyk-authorization:''wget --quiet \
--method DELETE \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/apis/:apiIDimport Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/apis/:apiID")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Get a list of OAuth clients bound to this back end
{{baseUrl}}/tyk/oauth/clients/:apiId
HEADERS
x-tyk-authorization
QUERY PARAMS
apiId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/oauth/clients/:apiId");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tyk/oauth/clients/:apiId" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/oauth/clients/:apiId"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
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}}/tyk/oauth/clients/:apiId"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/oauth/clients/:apiId");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/oauth/clients/:apiId"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tyk/oauth/clients/:apiId HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tyk/oauth/clients/:apiId")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/oauth/clients/:apiId"))
.header("x-tyk-authorization", "")
.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}}/tyk/oauth/clients/:apiId")
.get()
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tyk/oauth/clients/:apiId")
.header("x-tyk-authorization", "")
.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}}/tyk/oauth/clients/:apiId');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tyk/oauth/clients/:apiId',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/oauth/clients/:apiId';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
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}}/tyk/oauth/clients/:apiId',
method: 'GET',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/oauth/clients/:apiId")
.get()
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/oauth/clients/:apiId',
headers: {
'x-tyk-authorization': ''
}
};
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}}/tyk/oauth/clients/:apiId',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tyk/oauth/clients/:apiId');
req.headers({
'x-tyk-authorization': ''
});
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}}/tyk/oauth/clients/:apiId',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/oauth/clients/:apiId';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/oauth/clients/:apiId"]
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}}/tyk/oauth/clients/:apiId" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/oauth/clients/:apiId",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tyk/oauth/clients/:apiId', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/oauth/clients/:apiId');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/oauth/clients/:apiId');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/oauth/clients/:apiId' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/oauth/clients/:apiId' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("GET", "/baseUrl/tyk/oauth/clients/:apiId", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/oauth/clients/:apiId"
headers = {"x-tyk-authorization": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/oauth/clients/:apiId"
response <- VERB("GET", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/oauth/clients/:apiId")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tyk/oauth/clients/:apiId') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/oauth/clients/:apiId";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".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}}/tyk/oauth/clients/:apiId \
--header 'x-tyk-authorization: 'http GET {{baseUrl}}/tyk/oauth/clients/:apiId \
x-tyk-authorization:''wget --quiet \
--method GET \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/oauth/clients/:apiIdimport Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/oauth/clients/:apiId")! 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
Gets a list of -API Definition- objects that are currently live on the gateway
{{baseUrl}}/tyk/apis/
HEADERS
x-tyk-authorization
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/apis/");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tyk/apis/" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/apis/"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
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}}/tyk/apis/"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/apis/");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/apis/"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tyk/apis/ HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tyk/apis/")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/apis/"))
.header("x-tyk-authorization", "")
.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}}/tyk/apis/")
.get()
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tyk/apis/")
.header("x-tyk-authorization", "")
.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}}/tyk/apis/');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tyk/apis/',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/apis/';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
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}}/tyk/apis/',
method: 'GET',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/apis/")
.get()
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/apis/',
headers: {
'x-tyk-authorization': ''
}
};
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}}/tyk/apis/',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tyk/apis/');
req.headers({
'x-tyk-authorization': ''
});
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}}/tyk/apis/',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/apis/';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/apis/"]
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}}/tyk/apis/" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/apis/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tyk/apis/', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/apis/');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/apis/');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/apis/' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/apis/' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("GET", "/baseUrl/tyk/apis/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/apis/"
headers = {"x-tyk-authorization": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/apis/"
response <- VERB("GET", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/apis/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tyk/apis/') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/apis/";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".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}}/tyk/apis/ \
--header 'x-tyk-authorization: 'http GET {{baseUrl}}/tyk/apis/ \
x-tyk-authorization:''wget --quiet \
--method GET \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/apis/import Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/apis/")! 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
Gets a list of -key- IDs (will only work with non-hashed installations)
{{baseUrl}}/tyk/keys/
HEADERS
x-tyk-authorization
QUERY PARAMS
api_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/keys/?api_id=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tyk/keys/" {:headers {:x-tyk-authorization ""}
:query-params {:api_id ""}})require "http/client"
url = "{{baseUrl}}/tyk/keys/?api_id="
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
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}}/tyk/keys/?api_id="),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/keys/?api_id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/keys/?api_id="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tyk/keys/?api_id= HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tyk/keys/?api_id=")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/keys/?api_id="))
.header("x-tyk-authorization", "")
.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}}/tyk/keys/?api_id=")
.get()
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tyk/keys/?api_id=")
.header("x-tyk-authorization", "")
.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}}/tyk/keys/?api_id=');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tyk/keys/',
params: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/keys/?api_id=';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
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}}/tyk/keys/?api_id=',
method: 'GET',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/keys/?api_id=")
.get()
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/keys/?api_id=',
headers: {
'x-tyk-authorization': ''
}
};
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}}/tyk/keys/',
qs: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tyk/keys/');
req.query({
api_id: ''
});
req.headers({
'x-tyk-authorization': ''
});
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}}/tyk/keys/',
params: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/keys/?api_id=';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/keys/?api_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}}/tyk/keys/?api_id=" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/keys/?api_id=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tyk/keys/?api_id=', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/keys/');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'api_id' => ''
]);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/keys/');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'api_id' => ''
]));
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/keys/?api_id=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/keys/?api_id=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("GET", "/baseUrl/tyk/keys/?api_id=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/keys/"
querystring = {"api_id":""}
headers = {"x-tyk-authorization": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/keys/"
queryString <- list(api_id = "")
response <- VERB("GET", url, query = queryString, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/keys/?api_id=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tyk/keys/') do |req|
req.headers['x-tyk-authorization'] = ''
req.params['api_id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/keys/";
let querystring = [
("api_id", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/tyk/keys/?api_id=' \
--header 'x-tyk-authorization: 'http GET '{{baseUrl}}/tyk/keys/?api_id=' \
x-tyk-authorization:''wget --quiet \
--method GET \
--header 'x-tyk-authorization: ' \
--output-document \
- '{{baseUrl}}/tyk/keys/?api_id='import Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/keys/?api_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
Gets an -API Definition- object, if it exists
{{baseUrl}}/tyk/apis/:apiID
HEADERS
x-tyk-authorization
QUERY PARAMS
apiID
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/apis/:apiID");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tyk/apis/:apiID" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/apis/:apiID"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
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}}/tyk/apis/:apiID"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/apis/:apiID");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/apis/:apiID"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tyk/apis/:apiID HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tyk/apis/:apiID")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/apis/:apiID"))
.header("x-tyk-authorization", "")
.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}}/tyk/apis/:apiID")
.get()
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tyk/apis/:apiID")
.header("x-tyk-authorization", "")
.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}}/tyk/apis/:apiID');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tyk/apis/:apiID',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/apis/:apiID';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
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}}/tyk/apis/:apiID',
method: 'GET',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/apis/:apiID")
.get()
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/apis/:apiID',
headers: {
'x-tyk-authorization': ''
}
};
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}}/tyk/apis/:apiID',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tyk/apis/:apiID');
req.headers({
'x-tyk-authorization': ''
});
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}}/tyk/apis/:apiID',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/apis/:apiID';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/apis/:apiID"]
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}}/tyk/apis/:apiID" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/apis/:apiID",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tyk/apis/:apiID', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/apis/:apiID');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/apis/:apiID');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/apis/:apiID' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/apis/:apiID' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("GET", "/baseUrl/tyk/apis/:apiID", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/apis/:apiID"
headers = {"x-tyk-authorization": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/apis/:apiID"
response <- VERB("GET", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/apis/:apiID")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tyk/apis/:apiID') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/apis/:apiID";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".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}}/tyk/apis/:apiID \
--header 'x-tyk-authorization: 'http GET {{baseUrl}}/tyk/apis/:apiID \
x-tyk-authorization:''wget --quiet \
--method GET \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/apis/:apiIDimport Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/apis/:apiID")! 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
Gets the health check values for an API if it is being recorded
{{baseUrl}}/tyk/health/
HEADERS
x-tyk-authorization
QUERY PARAMS
api_id
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/health/?api_id=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tyk/health/" {:headers {:x-tyk-authorization ""}
:query-params {:api_id ""}})require "http/client"
url = "{{baseUrl}}/tyk/health/?api_id="
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
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}}/tyk/health/?api_id="),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/health/?api_id=");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/health/?api_id="
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tyk/health/?api_id= HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tyk/health/?api_id=")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/health/?api_id="))
.header("x-tyk-authorization", "")
.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}}/tyk/health/?api_id=")
.get()
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tyk/health/?api_id=")
.header("x-tyk-authorization", "")
.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}}/tyk/health/?api_id=');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tyk/health/',
params: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/health/?api_id=';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
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}}/tyk/health/?api_id=',
method: 'GET',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/health/?api_id=")
.get()
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/health/?api_id=',
headers: {
'x-tyk-authorization': ''
}
};
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}}/tyk/health/',
qs: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tyk/health/');
req.query({
api_id: ''
});
req.headers({
'x-tyk-authorization': ''
});
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}}/tyk/health/',
params: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/health/?api_id=';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/health/?api_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}}/tyk/health/?api_id=" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/health/?api_id=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tyk/health/?api_id=', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/health/');
$request->setMethod(HTTP_METH_GET);
$request->setQueryData([
'api_id' => ''
]);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/health/');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
'api_id' => ''
]));
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/health/?api_id=' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/health/?api_id=' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("GET", "/baseUrl/tyk/health/?api_id=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/health/"
querystring = {"api_id":""}
headers = {"x-tyk-authorization": ""}
response = requests.get(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/health/"
queryString <- list(api_id = "")
response <- VERB("GET", url, query = queryString, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/health/?api_id=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tyk/health/') do |req|
req.headers['x-tyk-authorization'] = ''
req.params['api_id'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/health/";
let querystring = [
("api_id", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url '{{baseUrl}}/tyk/health/?api_id=' \
--header 'x-tyk-authorization: 'http GET '{{baseUrl}}/tyk/health/?api_id=' \
x-tyk-authorization:''wget --quiet \
--method GET \
--header 'x-tyk-authorization: ' \
--output-document \
- '{{baseUrl}}/tyk/health/?api_id='import Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/health/?api_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()
DELETE
Invalidate a refresh token
{{baseUrl}}/tyk/oauth/refresh/:keyId
HEADERS
x-tyk-authorization
QUERY PARAMS
apiID
keyId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/tyk/oauth/refresh/:keyId" {:headers {:x-tyk-authorization ""}
:query-params {:apiID ""}})require "http/client"
url = "{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID="
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID="),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID="
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/tyk/oauth/refresh/:keyId?apiID= HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID="))
.header("x-tyk-authorization", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=")
.delete(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/oauth/refresh/:keyId',
params: {apiID: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=';
const options = {method: 'DELETE', headers: {'x-tyk-authorization': ''}};
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}}/tyk/oauth/refresh/:keyId?apiID=',
method: 'DELETE',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=")
.delete(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/oauth/refresh/:keyId?apiID=',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/oauth/refresh/:keyId',
qs: {apiID: ''},
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/tyk/oauth/refresh/:keyId');
req.query({
apiID: ''
});
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/oauth/refresh/:keyId',
params: {apiID: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=';
const options = {method: 'DELETE', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/oauth/refresh/:keyId');
$request->setMethod(HTTP_METH_DELETE);
$request->setQueryData([
'apiID' => ''
]);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/oauth/refresh/:keyId');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
'apiID' => ''
]));
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("DELETE", "/baseUrl/tyk/oauth/refresh/:keyId?apiID=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/oauth/refresh/:keyId"
querystring = {"apiID":""}
headers = {"x-tyk-authorization": ""}
response = requests.delete(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/oauth/refresh/:keyId"
queryString <- list(apiID = "")
response <- VERB("DELETE", url, query = queryString, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/tyk/oauth/refresh/:keyId') do |req|
req.headers['x-tyk-authorization'] = ''
req.params['apiID'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/oauth/refresh/:keyId";
let querystring = [
("apiID", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url '{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=' \
--header 'x-tyk-authorization: 'http DELETE '{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=' \
x-tyk-authorization:''wget --quiet \
--method DELETE \
--header 'x-tyk-authorization: ' \
--output-document \
- '{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID='import Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/oauth/refresh/:keyId?apiID=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
DELETE
Remove this -API token- from the gateway, this will completely destroy the token and metadata associated with the token and instantly stop access from being granted
{{baseUrl}}/tyk/keys/:keyId
HEADERS
x-tyk-authorization
QUERY PARAMS
api_id
keyId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/keys/:keyId?api_id=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/delete "{{baseUrl}}/tyk/keys/:keyId" {:headers {:x-tyk-authorization ""}
:query-params {:api_id ""}})require "http/client"
url = "{{baseUrl}}/tyk/keys/:keyId?api_id="
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.delete url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Delete,
RequestUri = new Uri("{{baseUrl}}/tyk/keys/:keyId?api_id="),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/keys/:keyId?api_id=");
var request = new RestRequest("", Method.Delete);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/keys/:keyId?api_id="
req, _ := http.NewRequest("DELETE", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}DELETE /baseUrl/tyk/keys/:keyId?api_id= HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tyk/keys/:keyId?api_id=")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/keys/:keyId?api_id="))
.header("x-tyk-authorization", "")
.method("DELETE", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/keys/:keyId?api_id=")
.delete(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.delete("{{baseUrl}}/tyk/keys/:keyId?api_id=")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('DELETE', '{{baseUrl}}/tyk/keys/:keyId?api_id=');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/keys/:keyId',
params: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/keys/:keyId?api_id=';
const options = {method: 'DELETE', headers: {'x-tyk-authorization': ''}};
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}}/tyk/keys/:keyId?api_id=',
method: 'DELETE',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/keys/:keyId?api_id=")
.delete(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'DELETE',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/keys/:keyId?api_id=',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/keys/:keyId',
qs: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('DELETE', '{{baseUrl}}/tyk/keys/:keyId');
req.query({
api_id: ''
});
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'DELETE',
url: '{{baseUrl}}/tyk/keys/:keyId',
params: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/keys/:keyId?api_id=';
const options = {method: 'DELETE', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/keys/:keyId?api_id="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/keys/:keyId?api_id=" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/keys/:keyId?api_id=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "DELETE",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('DELETE', '{{baseUrl}}/tyk/keys/:keyId?api_id=', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/keys/:keyId');
$request->setMethod(HTTP_METH_DELETE);
$request->setQueryData([
'api_id' => ''
]);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/keys/:keyId');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
'api_id' => ''
]));
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/keys/:keyId?api_id=' -Method DELETE -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/keys/:keyId?api_id=' -Method DELETE -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("DELETE", "/baseUrl/tyk/keys/:keyId?api_id=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/keys/:keyId"
querystring = {"api_id":""}
headers = {"x-tyk-authorization": ""}
response = requests.delete(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/keys/:keyId"
queryString <- list(api_id = "")
response <- VERB("DELETE", url, query = queryString, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/keys/:keyId?api_id=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.delete('/baseUrl/tyk/keys/:keyId') do |req|
req.headers['x-tyk-authorization'] = ''
req.params['api_id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/keys/:keyId";
let querystring = [
("api_id", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request DELETE \
--url '{{baseUrl}}/tyk/keys/:keyId?api_id=' \
--header 'x-tyk-authorization: 'http DELETE '{{baseUrl}}/tyk/keys/:keyId?api_id=' \
x-tyk-authorization:''wget --quiet \
--method DELETE \
--header 'x-tyk-authorization: ' \
--output-document \
- '{{baseUrl}}/tyk/keys/:keyId?api_id='import Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/keys/:keyId?api_id=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
POST
The final request from an authorising party for a redirect URI during the Tyk OAuth flow
{{baseUrl}}/tyk/oauth/authorize-client/
HEADERS
x-tyk-authorization
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/oauth/authorize-client/");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/tyk/oauth/authorize-client/" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/oauth/authorize-client/"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/tyk/oauth/authorize-client/"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/oauth/authorize-client/");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/oauth/authorize-client/"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}POST /baseUrl/tyk/oauth/authorize-client/ HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tyk/oauth/authorize-client/")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/oauth/authorize-client/"))
.header("x-tyk-authorization", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/oauth/authorize-client/")
.post(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/tyk/oauth/authorize-client/")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('POST', '{{baseUrl}}/tyk/oauth/authorize-client/');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/oauth/authorize-client/',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/oauth/authorize-client/';
const options = {method: 'POST', headers: {'x-tyk-authorization': ''}};
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}}/tyk/oauth/authorize-client/',
method: 'POST',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/oauth/authorize-client/")
.post(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'POST',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/oauth/authorize-client/',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/oauth/authorize-client/',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('POST', '{{baseUrl}}/tyk/oauth/authorize-client/');
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'POST',
url: '{{baseUrl}}/tyk/oauth/authorize-client/',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/oauth/authorize-client/';
const options = {method: 'POST', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/oauth/authorize-client/"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/oauth/authorize-client/" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/oauth/authorize-client/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('POST', '{{baseUrl}}/tyk/oauth/authorize-client/', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/oauth/authorize-client/');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/oauth/authorize-client/');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/oauth/authorize-client/' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/oauth/authorize-client/' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("POST", "/baseUrl/tyk/oauth/authorize-client/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/oauth/authorize-client/"
headers = {"x-tyk-authorization": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/oauth/authorize-client/"
response <- VERB("POST", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/oauth/authorize-client/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/tyk/oauth/authorize-client/') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/oauth/authorize-client/";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url {{baseUrl}}/tyk/oauth/authorize-client/ \
--header 'x-tyk-authorization: 'http POST {{baseUrl}}/tyk/oauth/authorize-client/ \
x-tyk-authorization:''wget --quiet \
--method POST \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/oauth/authorize-client/import Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/oauth/authorize-client/")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Update an -API token- with the -session object- defined in the body, this operatin overwrites the existing object
{{baseUrl}}/tyk/keys/:keyId
HEADERS
x-tyk-authorization
QUERY PARAMS
api_id
keyId
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/keys/:keyId?api_id=");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/tyk/keys/:keyId" {:headers {:x-tyk-authorization ""}
:query-params {:api_id ""}})require "http/client"
url = "{{baseUrl}}/tyk/keys/:keyId?api_id="
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/tyk/keys/:keyId?api_id="),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/keys/:keyId?api_id=");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/keys/:keyId?api_id="
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/tyk/keys/:keyId?api_id= HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/tyk/keys/:keyId?api_id=")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/keys/:keyId?api_id="))
.header("x-tyk-authorization", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/keys/:keyId?api_id=")
.put(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/tyk/keys/:keyId?api_id=")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/tyk/keys/:keyId?api_id=');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/tyk/keys/:keyId',
params: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/keys/:keyId?api_id=';
const options = {method: 'PUT', headers: {'x-tyk-authorization': ''}};
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}}/tyk/keys/:keyId?api_id=',
method: 'PUT',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/keys/:keyId?api_id=")
.put(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/keys/:keyId?api_id=',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/tyk/keys/:keyId',
qs: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/tyk/keys/:keyId');
req.query({
api_id: ''
});
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/tyk/keys/:keyId',
params: {api_id: ''},
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/keys/:keyId?api_id=';
const options = {method: 'PUT', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/keys/:keyId?api_id="]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/keys/:keyId?api_id=" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/keys/:keyId?api_id=",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/tyk/keys/:keyId?api_id=', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/keys/:keyId');
$request->setMethod(HTTP_METH_PUT);
$request->setQueryData([
'api_id' => ''
]);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/keys/:keyId');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
'api_id' => ''
]));
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/keys/:keyId?api_id=' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/keys/:keyId?api_id=' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("PUT", "/baseUrl/tyk/keys/:keyId?api_id=", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/keys/:keyId"
querystring = {"api_id":""}
headers = {"x-tyk-authorization": ""}
response = requests.put(url, headers=headers, params=querystring)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/keys/:keyId"
queryString <- list(api_id = "")
response <- VERB("PUT", url, query = queryString, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/keys/:keyId?api_id=")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/tyk/keys/:keyId') do |req|
req.headers['x-tyk-authorization'] = ''
req.params['api_id'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/keys/:keyId";
let querystring = [
("api_id", ""),
];
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.query(&querystring)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url '{{baseUrl}}/tyk/keys/:keyId?api_id=' \
--header 'x-tyk-authorization: 'http PUT '{{baseUrl}}/tyk/keys/:keyId?api_id=' \
x-tyk-authorization:''wget --quiet \
--method PUT \
--header 'x-tyk-authorization: ' \
--output-document \
- '{{baseUrl}}/tyk/keys/:keyId?api_id='import Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/keys/:keyId?api_id=")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
PUT
Updates an -API Definition- object, if it exists
{{baseUrl}}/tyk/apis/:apiID
HEADERS
x-tyk-authorization
QUERY PARAMS
apiID
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/apis/:apiID");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/put "{{baseUrl}}/tyk/apis/:apiID" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/apis/:apiID"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
response = HTTP::Client.put url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("{{baseUrl}}/tyk/apis/:apiID"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/apis/:apiID");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/apis/:apiID"
req, _ := http.NewRequest("PUT", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}PUT /baseUrl/tyk/apis/:apiID HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/tyk/apis/:apiID")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/apis/:apiID"))
.header("x-tyk-authorization", "")
.method("PUT", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/tyk/apis/:apiID")
.put(null)
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.put("{{baseUrl}}/tyk/apis/:apiID")
.header("x-tyk-authorization", "")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('PUT', '{{baseUrl}}/tyk/apis/:apiID');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'PUT',
url: '{{baseUrl}}/tyk/apis/:apiID',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/apis/:apiID';
const options = {method: 'PUT', headers: {'x-tyk-authorization': ''}};
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}}/tyk/apis/:apiID',
method: 'PUT',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/apis/:apiID")
.put(null)
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'PUT',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/apis/:apiID',
headers: {
'x-tyk-authorization': ''
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'PUT',
url: '{{baseUrl}}/tyk/apis/:apiID',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('PUT', '{{baseUrl}}/tyk/apis/:apiID');
req.headers({
'x-tyk-authorization': ''
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'PUT',
url: '{{baseUrl}}/tyk/apis/:apiID',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/apis/:apiID';
const options = {method: 'PUT', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/apis/:apiID"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/tyk/apis/:apiID" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `PUT uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/apis/:apiID",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "PUT",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('PUT', '{{baseUrl}}/tyk/apis/:apiID', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/apis/:apiID');
$request->setMethod(HTTP_METH_PUT);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/apis/:apiID');
$request->setRequestMethod('PUT');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/apis/:apiID' -Method PUT -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/apis/:apiID' -Method PUT -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("PUT", "/baseUrl/tyk/apis/:apiID", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/apis/:apiID"
headers = {"x-tyk-authorization": ""}
response = requests.put(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/apis/:apiID"
response <- VERB("PUT", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/apis/:apiID")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Put.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.put('/baseUrl/tyk/apis/:apiID') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse std::str::FromStr;
use reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/apis/:apiID";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request PUT \
--url {{baseUrl}}/tyk/apis/:apiID \
--header 'x-tyk-authorization: 'http PUT {{baseUrl}}/tyk/apis/:apiID \
x-tyk-authorization:''wget --quiet \
--method PUT \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/apis/:apiIDimport Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/apis/:apiID")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
GET
Will reload the cluster via the targeted gateway
{{baseUrl}}/tyk/reload/group
HEADERS
x-tyk-authorization
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/reload/group");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tyk/reload/group" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/reload/group"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
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}}/tyk/reload/group"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/reload/group");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/reload/group"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tyk/reload/group HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tyk/reload/group")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/reload/group"))
.header("x-tyk-authorization", "")
.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}}/tyk/reload/group")
.get()
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tyk/reload/group")
.header("x-tyk-authorization", "")
.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}}/tyk/reload/group');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tyk/reload/group',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/reload/group';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
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}}/tyk/reload/group',
method: 'GET',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/reload/group")
.get()
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/reload/group',
headers: {
'x-tyk-authorization': ''
}
};
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}}/tyk/reload/group',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tyk/reload/group');
req.headers({
'x-tyk-authorization': ''
});
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}}/tyk/reload/group',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/reload/group';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/reload/group"]
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}}/tyk/reload/group" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/reload/group",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tyk/reload/group', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/reload/group');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/reload/group');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/reload/group' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/reload/group' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("GET", "/baseUrl/tyk/reload/group", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/reload/group"
headers = {"x-tyk-authorization": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/reload/group"
response <- VERB("GET", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/reload/group")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tyk/reload/group') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/reload/group";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".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}}/tyk/reload/group \
--header 'x-tyk-authorization: 'http GET {{baseUrl}}/tyk/reload/group \
x-tyk-authorization:''wget --quiet \
--method GET \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/reload/groupimport Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/reload/group")! 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
Will reload the targetted gateway
{{baseUrl}}/tyk/reload/
HEADERS
x-tyk-authorization
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tyk/reload/");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tyk-authorization: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/tyk/reload/" {:headers {:x-tyk-authorization ""}})require "http/client"
url = "{{baseUrl}}/tyk/reload/"
headers = HTTP::Headers{
"x-tyk-authorization" => ""
}
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}}/tyk/reload/"),
Headers =
{
{ "x-tyk-authorization", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/tyk/reload/");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tyk-authorization", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/tyk/reload/"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tyk-authorization", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/tyk/reload/ HTTP/1.1
X-Tyk-Authorization:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tyk/reload/")
.setHeader("x-tyk-authorization", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/tyk/reload/"))
.header("x-tyk-authorization", "")
.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}}/tyk/reload/")
.get()
.addHeader("x-tyk-authorization", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/tyk/reload/")
.header("x-tyk-authorization", "")
.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}}/tyk/reload/');
xhr.setRequestHeader('x-tyk-authorization', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/tyk/reload/',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/tyk/reload/';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
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}}/tyk/reload/',
method: 'GET',
headers: {
'x-tyk-authorization': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/tyk/reload/")
.get()
.addHeader("x-tyk-authorization", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/tyk/reload/',
headers: {
'x-tyk-authorization': ''
}
};
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}}/tyk/reload/',
headers: {'x-tyk-authorization': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/tyk/reload/');
req.headers({
'x-tyk-authorization': ''
});
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}}/tyk/reload/',
headers: {'x-tyk-authorization': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/tyk/reload/';
const options = {method: 'GET', headers: {'x-tyk-authorization': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tyk-authorization": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tyk/reload/"]
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}}/tyk/reload/" in
let headers = Header.add (Header.init ()) "x-tyk-authorization" "" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/tyk/reload/",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"x-tyk-authorization: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/tyk/reload/', [
'headers' => [
'x-tyk-authorization' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/tyk/reload/');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tyk-authorization' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/tyk/reload/');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tyk-authorization' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tyk/reload/' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tyk-authorization", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tyk/reload/' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tyk-authorization': "" }
conn.request("GET", "/baseUrl/tyk/reload/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/tyk/reload/"
headers = {"x-tyk-authorization": ""}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/tyk/reload/"
response <- VERB("GET", url, add_headers('x-tyk-authorization' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/tyk/reload/")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tyk-authorization"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/tyk/reload/') do |req|
req.headers['x-tyk-authorization'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/tyk/reload/";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tyk-authorization", "".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}}/tyk/reload/ \
--header 'x-tyk-authorization: 'http GET {{baseUrl}}/tyk/reload/ \
x-tyk-authorization:''wget --quiet \
--method GET \
--header 'x-tyk-authorization: ' \
--output-document \
- {{baseUrl}}/tyk/reload/import Foundation
let headers = ["x-tyk-authorization": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tyk/reload/")! 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()