The Blue Alliance API v3
The Blue Alliance API v3v3.8.2
Overview Information and statistics about FIRST Robotics Competition teams and events. Authentication All endpoints require an Auth Key to be passed in the header X-TBA-Auth-Key. If you do not have an auth key yet, you can obtain one from your Account Page.
- Endpoints
- 65 (65 GET)
- Base URL
https://www.thebluealliance.com/api/v3- Authentication
- API key
- Spec format
- OpenAPI 3.0.1
- API version
- 3.8.2
- Source
- thebluealliance.com
- Provider
- thebluealliance.com
- Categories
- Open Data
- Last updated
Use this API in Bruno:
- Download the Bruno collection above and unzip it.
- In Bruno, choose Open Collection and select the unzipped folder.
- Set the
baseUrlvariable (for examplehttps://www.thebluealliance.com/api/v3) and your API key credentials, then send requests.
GET
getDistrictEvents
{{baseUrl}}/district/:district_key/events
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
district_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/district/:district_key/events");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/district/:district_key/events" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/district/:district_key/events"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/district/:district_key/events"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/district/:district_key/events");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/district/:district_key/events"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/district/:district_key/events HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/district/:district_key/events")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/district/:district_key/events"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/district/:district_key/events")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/district/:district_key/events")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/district/:district_key/events');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/events',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/district/:district_key/events';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/district/:district_key/events',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/district/:district_key/events")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/district/:district_key/events',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/events',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/district/:district_key/events');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/events',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/district/:district_key/events';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/district/:district_key/events"]
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}}/district/:district_key/events" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/district/:district_key/events",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/district/:district_key/events', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/district/:district_key/events');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/district/:district_key/events');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/district/:district_key/events' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/district/:district_key/events' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/district/:district_key/events", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/district/:district_key/events"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/district/:district_key/events"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/district/:district_key/events")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/district/:district_key/events') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/district/:district_key/events";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/district/:district_key/events \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/district/:district_key/events \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/district/:district_key/eventsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/district/:district_key/events")! 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
getDistrictEventsKeys
{{baseUrl}}/district/:district_key/events/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
district_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/district/:district_key/events/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/district/:district_key/events/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/district/:district_key/events/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/district/:district_key/events/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/district/:district_key/events/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/district/:district_key/events/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/district/:district_key/events/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/district/:district_key/events/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/district/:district_key/events/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/district/:district_key/events/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/district/:district_key/events/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/district/:district_key/events/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/events/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/district/:district_key/events/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/district/:district_key/events/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/district/:district_key/events/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/district/:district_key/events/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/events/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/district/:district_key/events/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/events/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/district/:district_key/events/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/district/:district_key/events/keys"]
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}}/district/:district_key/events/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/district/:district_key/events/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/district/:district_key/events/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/district/:district_key/events/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/district/:district_key/events/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/district/:district_key/events/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/district/:district_key/events/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/district/:district_key/events/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/district/:district_key/events/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/district/:district_key/events/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/district/:district_key/events/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/district/:district_key/events/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/district/:district_key/events/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/district/:district_key/events/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/district/:district_key/events/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/district/:district_key/events/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/district/:district_key/events/keys")! 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
getDistrictEventsSimple
{{baseUrl}}/district/:district_key/events/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
district_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/district/:district_key/events/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/district/:district_key/events/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/district/:district_key/events/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/district/:district_key/events/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/district/:district_key/events/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/district/:district_key/events/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/district/:district_key/events/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/district/:district_key/events/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/district/:district_key/events/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/district/:district_key/events/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/district/:district_key/events/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/district/:district_key/events/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/events/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/district/:district_key/events/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/district/:district_key/events/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/district/:district_key/events/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/district/:district_key/events/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/events/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/district/:district_key/events/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/events/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/district/:district_key/events/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/district/:district_key/events/simple"]
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}}/district/:district_key/events/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/district/:district_key/events/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/district/:district_key/events/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/district/:district_key/events/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/district/:district_key/events/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/district/:district_key/events/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/district/:district_key/events/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/district/:district_key/events/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/district/:district_key/events/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/district/:district_key/events/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/district/:district_key/events/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/district/:district_key/events/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/district/:district_key/events/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/district/:district_key/events/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/district/:district_key/events/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/district/:district_key/events/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/district/:district_key/events/simple")! 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
getDistrictRankings
{{baseUrl}}/district/:district_key/rankings
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
district_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/district/:district_key/rankings");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/district/:district_key/rankings" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/district/:district_key/rankings"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/district/:district_key/rankings"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/district/:district_key/rankings");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/district/:district_key/rankings"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/district/:district_key/rankings HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/district/:district_key/rankings")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/district/:district_key/rankings"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/district/:district_key/rankings")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/district/:district_key/rankings")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/district/:district_key/rankings');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/rankings',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/district/:district_key/rankings';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/district/:district_key/rankings',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/district/:district_key/rankings")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/district/:district_key/rankings',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/rankings',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/district/:district_key/rankings');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/rankings',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/district/:district_key/rankings';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/district/:district_key/rankings"]
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}}/district/:district_key/rankings" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/district/:district_key/rankings",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/district/:district_key/rankings', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/district/:district_key/rankings');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/district/:district_key/rankings');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/district/:district_key/rankings' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/district/:district_key/rankings' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/district/:district_key/rankings", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/district/:district_key/rankings"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/district/:district_key/rankings"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/district/:district_key/rankings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/district/:district_key/rankings') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/district/:district_key/rankings";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/district/:district_key/rankings \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/district/:district_key/rankings \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/district/:district_key/rankingsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/district/:district_key/rankings")! 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
getDistrictTeams
{{baseUrl}}/district/:district_key/teams
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
district_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/district/:district_key/teams");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/district/:district_key/teams" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/district/:district_key/teams"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/district/:district_key/teams"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/district/:district_key/teams");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/district/:district_key/teams"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/district/:district_key/teams HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/district/:district_key/teams")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/district/:district_key/teams"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/district/:district_key/teams")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/district/:district_key/teams")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/district/:district_key/teams');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/teams',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/district/:district_key/teams';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/district/:district_key/teams',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/district/:district_key/teams")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/district/:district_key/teams',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/teams',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/district/:district_key/teams');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/teams',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/district/:district_key/teams';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/district/:district_key/teams"]
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}}/district/:district_key/teams" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/district/:district_key/teams",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/district/:district_key/teams', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/district/:district_key/teams');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/district/:district_key/teams');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/district/:district_key/teams' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/district/:district_key/teams' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/district/:district_key/teams", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/district/:district_key/teams"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/district/:district_key/teams"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/district/:district_key/teams")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/district/:district_key/teams') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/district/:district_key/teams";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/district/:district_key/teams \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/district/:district_key/teams \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/district/:district_key/teamsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/district/:district_key/teams")! 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
getDistrictTeamsKeys
{{baseUrl}}/district/:district_key/teams/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
district_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/district/:district_key/teams/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/district/:district_key/teams/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/district/:district_key/teams/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/district/:district_key/teams/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/district/:district_key/teams/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/district/:district_key/teams/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/district/:district_key/teams/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/district/:district_key/teams/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/district/:district_key/teams/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/district/:district_key/teams/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/district/:district_key/teams/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/district/:district_key/teams/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/teams/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/district/:district_key/teams/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/district/:district_key/teams/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/district/:district_key/teams/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/district/:district_key/teams/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/teams/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/district/:district_key/teams/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/teams/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/district/:district_key/teams/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/district/:district_key/teams/keys"]
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}}/district/:district_key/teams/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/district/:district_key/teams/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/district/:district_key/teams/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/district/:district_key/teams/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/district/:district_key/teams/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/district/:district_key/teams/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/district/:district_key/teams/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/district/:district_key/teams/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/district/:district_key/teams/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/district/:district_key/teams/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/district/:district_key/teams/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/district/:district_key/teams/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/district/:district_key/teams/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/district/:district_key/teams/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/district/:district_key/teams/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/district/:district_key/teams/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/district/:district_key/teams/keys")! 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
getDistrictTeamsSimple
{{baseUrl}}/district/:district_key/teams/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
district_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/district/:district_key/teams/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/district/:district_key/teams/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/district/:district_key/teams/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/district/:district_key/teams/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/district/:district_key/teams/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/district/:district_key/teams/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/district/:district_key/teams/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/district/:district_key/teams/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/district/:district_key/teams/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/district/:district_key/teams/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/district/:district_key/teams/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/district/:district_key/teams/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/teams/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/district/:district_key/teams/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/district/:district_key/teams/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/district/:district_key/teams/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/district/:district_key/teams/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/teams/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/district/:district_key/teams/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/district/:district_key/teams/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/district/:district_key/teams/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/district/:district_key/teams/simple"]
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}}/district/:district_key/teams/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/district/:district_key/teams/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/district/:district_key/teams/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/district/:district_key/teams/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/district/:district_key/teams/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/district/:district_key/teams/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/district/:district_key/teams/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/district/:district_key/teams/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/district/:district_key/teams/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/district/:district_key/teams/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/district/:district_key/teams/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/district/:district_key/teams/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/district/:district_key/teams/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/district/:district_key/teams/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/district/:district_key/teams/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/district/:district_key/teams/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/district/:district_key/teams/simple")! 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
getDistrictsByYear
{{baseUrl}}/districts/:year
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/districts/:year");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/districts/:year" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/districts/:year"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/districts/:year"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/districts/:year");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/districts/:year"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/districts/:year HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/districts/:year")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/districts/:year"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/districts/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/districts/:year")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/districts/:year');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/districts/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/districts/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/districts/:year',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/districts/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/districts/:year',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/districts/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/districts/:year');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/districts/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/districts/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/districts/:year"]
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}}/districts/:year" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/districts/:year",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/districts/:year', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/districts/:year');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/districts/:year');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/districts/:year' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/districts/:year' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/districts/:year", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/districts/:year"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/districts/:year"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/districts/:year")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/districts/:year') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/districts/:year";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/districts/:year \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/districts/:year \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/districts/:yearimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/districts/:year")! 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
getEvent
{{baseUrl}}/event/:event_key
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key"]
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}}/event/:event_key" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_keyimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key")! 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
getEventAlliances
{{baseUrl}}/event/:event_key/alliances
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/alliances");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/alliances" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/alliances"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/alliances"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/alliances");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/alliances"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/alliances HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/alliances")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/alliances"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/alliances")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/alliances")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/alliances');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/alliances',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/alliances';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/alliances',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/alliances")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/alliances',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/alliances',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/alliances');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/alliances',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/alliances';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/alliances"]
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}}/event/:event_key/alliances" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/alliances",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/alliances', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/alliances');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/alliances');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/alliances' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/alliances' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/alliances", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/alliances"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/alliances"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/alliances")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/alliances') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/alliances";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/alliances \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/alliances \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/alliancesimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/alliances")! 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
getEventAwards
{{baseUrl}}/event/:event_key/awards
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/awards");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/awards" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/awards"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/awards"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/awards");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/awards"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/awards HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/awards")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/awards"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/awards")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/awards")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/awards');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/awards',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/awards';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/awards',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/awards")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/awards',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/awards',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/awards');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/awards',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/awards';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/awards"]
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}}/event/:event_key/awards" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/awards",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/awards', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/awards');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/awards');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/awards' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/awards' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/awards", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/awards"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/awards"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/awards")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/awards') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/awards";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/awards \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/awards \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/awardsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/awards")! 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
getEventDistrictPoints
{{baseUrl}}/event/:event_key/district_points
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/district_points");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/district_points" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/district_points"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/district_points"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/district_points");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/district_points"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/district_points HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/district_points")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/district_points"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/district_points")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/district_points")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/district_points');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/district_points',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/district_points';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/district_points',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/district_points")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/district_points',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/district_points',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/district_points');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/district_points',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/district_points';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/district_points"]
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}}/event/:event_key/district_points" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/district_points",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/district_points', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/district_points');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/district_points');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/district_points' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/district_points' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/district_points", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/district_points"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/district_points"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/district_points")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/district_points') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/district_points";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/district_points \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/district_points \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/district_pointsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/district_points")! 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
getEventInsights
{{baseUrl}}/event/:event_key/insights
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/insights");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/insights" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/insights"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/insights"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/insights");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/insights"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/insights HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/insights")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/insights"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/insights")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/insights")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/insights');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/insights',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/insights';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/insights',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/insights")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/insights',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/insights',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/insights');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/insights',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/insights';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/insights"]
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}}/event/:event_key/insights" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/insights",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/insights', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/insights');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/insights');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/insights' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/insights' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/insights", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/insights"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/insights"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/insights")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/insights') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/insights";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/insights \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/insights \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/insightsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/insights")! 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
getEventMatchTimeseries
{{baseUrl}}/event/:event_key/matches/timeseries
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/matches/timeseries");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/matches/timeseries" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/matches/timeseries"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/matches/timeseries"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/matches/timeseries");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/matches/timeseries"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/matches/timeseries HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/matches/timeseries")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/matches/timeseries"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/matches/timeseries")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/matches/timeseries")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/matches/timeseries');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches/timeseries',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/matches/timeseries';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/matches/timeseries',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/matches/timeseries")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/matches/timeseries',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches/timeseries',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/matches/timeseries');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches/timeseries',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/matches/timeseries';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/matches/timeseries"]
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}}/event/:event_key/matches/timeseries" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/matches/timeseries",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/matches/timeseries', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/matches/timeseries');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/matches/timeseries');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/matches/timeseries' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/matches/timeseries' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/matches/timeseries", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/matches/timeseries"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/matches/timeseries"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/matches/timeseries")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/matches/timeseries') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/matches/timeseries";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/matches/timeseries \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/matches/timeseries \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/matches/timeseriesimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/matches/timeseries")! 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
getEventMatches
{{baseUrl}}/event/:event_key/matches
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/matches");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/matches" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/matches"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/matches"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/matches");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/matches"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/matches HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/matches")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/matches"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/matches")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/matches")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/matches');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/matches';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/matches',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/matches")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/matches',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/matches');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/matches';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/matches"]
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}}/event/:event_key/matches" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/matches",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/matches', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/matches');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/matches');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/matches' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/matches' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/matches", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/matches"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/matches"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/matches")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/matches') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/matches";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/matches \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/matches \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/matchesimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/matches")! 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
getEventMatchesKeys
{{baseUrl}}/event/:event_key/matches/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/matches/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/matches/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/matches/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/matches/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/matches/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/matches/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/matches/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/matches/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/matches/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/matches/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/matches/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/matches/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/matches/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/matches/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/matches/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/matches/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/matches/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/matches/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/matches/keys"]
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}}/event/:event_key/matches/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/matches/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/matches/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/matches/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/matches/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/matches/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/matches/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/matches/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/matches/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/matches/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/matches/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/matches/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/matches/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/matches/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/matches/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/matches/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/matches/keys")! 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
getEventMatchesSimple
{{baseUrl}}/event/:event_key/matches/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/matches/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/matches/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/matches/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/matches/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/matches/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/matches/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/matches/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/matches/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/matches/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/matches/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/matches/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/matches/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/matches/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/matches/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/matches/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/matches/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/matches/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/matches/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/matches/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/matches/simple"]
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}}/event/:event_key/matches/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/matches/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/matches/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/matches/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/matches/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/matches/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/matches/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/matches/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/matches/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/matches/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/matches/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/matches/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/matches/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/matches/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/matches/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/matches/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/matches/simple")! 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
getEventOPRs
{{baseUrl}}/event/:event_key/oprs
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/oprs");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/oprs" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/oprs"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/oprs"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/oprs");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/oprs"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/oprs HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/oprs")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/oprs"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/oprs")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/oprs")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/oprs');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/oprs',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/oprs';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/oprs',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/oprs")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/oprs',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/oprs',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/oprs');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/oprs',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/oprs';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/oprs"]
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}}/event/:event_key/oprs" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/oprs",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/oprs', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/oprs');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/oprs');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/oprs' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/oprs' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/oprs", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/oprs"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/oprs"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/oprs")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/oprs') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/oprs";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/oprs \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/oprs \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/oprsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/oprs")! 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
getEventPredictions
{{baseUrl}}/event/:event_key/predictions
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/predictions");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/predictions" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/predictions"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/predictions"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/predictions");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/predictions"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/predictions HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/predictions")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/predictions"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/predictions")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/predictions")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/predictions');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/predictions',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/predictions';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/predictions',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/predictions")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/predictions',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/predictions',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/predictions');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/predictions',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/predictions';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/predictions"]
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}}/event/:event_key/predictions" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/predictions",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/predictions', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/predictions');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/predictions');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/predictions' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/predictions' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/predictions", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/predictions"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/predictions"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/predictions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/predictions') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/predictions";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/predictions \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/predictions \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/predictionsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/predictions")! 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
getEventRankings
{{baseUrl}}/event/:event_key/rankings
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/rankings");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/rankings" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/rankings"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/rankings"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/rankings");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/rankings"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/rankings HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/rankings")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/rankings"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/rankings")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/rankings")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/rankings');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/rankings',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/rankings';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/rankings',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/rankings")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/rankings',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/rankings',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/rankings');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/rankings',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/rankings';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/rankings"]
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}}/event/:event_key/rankings" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/rankings",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/rankings', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/rankings');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/rankings');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/rankings' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/rankings' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/rankings", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/rankings"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/rankings"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/rankings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/rankings') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/rankings";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/rankings \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/rankings \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/rankingsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/rankings")! 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
getEventSimple
{{baseUrl}}/event/:event_key/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/simple"]
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}}/event/:event_key/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/simple")! 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
getEventTeams
{{baseUrl}}/event/:event_key/teams
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/teams");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/teams" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/teams"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/teams"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/teams");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/teams"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/teams HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/teams")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/teams"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/teams")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/teams")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/teams');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/teams';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/teams',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/teams")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/teams',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/teams');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/teams';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/teams"]
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}}/event/:event_key/teams" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/teams",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/teams', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/teams');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/teams');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/teams' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/teams' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/teams", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/teams"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/teams"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/teams")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/teams') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/teams";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/teams \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/teams \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/teamsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/teams")! 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
getEventTeamsKeys
{{baseUrl}}/event/:event_key/teams/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/teams/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/teams/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/teams/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/teams/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/teams/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/teams/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/teams/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/teams/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/teams/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/teams/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/teams/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/teams/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/teams/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/teams/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/teams/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/teams/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/teams/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/teams/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/teams/keys"]
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}}/event/:event_key/teams/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/teams/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/teams/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/teams/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/teams/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/teams/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/teams/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/teams/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/teams/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/teams/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/teams/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/teams/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/teams/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/teams/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/teams/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/teams/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/teams/keys")! 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
getEventTeamsSimple
{{baseUrl}}/event/:event_key/teams/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/teams/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/teams/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/teams/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/teams/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/teams/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/teams/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/teams/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/teams/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/teams/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/teams/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/teams/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/teams/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/teams/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/teams/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/teams/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/teams/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/teams/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/teams/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/teams/simple"]
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}}/event/:event_key/teams/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/teams/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/teams/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/teams/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/teams/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/teams/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/teams/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/teams/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/teams/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/teams/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/teams/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/teams/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/teams/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/teams/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/teams/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/teams/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/teams/simple")! 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
getEventTeamsStatuses
{{baseUrl}}/event/:event_key/teams/statuses
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/event/:event_key/teams/statuses");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/event/:event_key/teams/statuses" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/event/:event_key/teams/statuses"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/event/:event_key/teams/statuses"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/event/:event_key/teams/statuses");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/event/:event_key/teams/statuses"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/event/:event_key/teams/statuses HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/event/:event_key/teams/statuses")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/event/:event_key/teams/statuses"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/event/:event_key/teams/statuses")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/event/:event_key/teams/statuses")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/event/:event_key/teams/statuses');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams/statuses',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/event/:event_key/teams/statuses';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/event/:event_key/teams/statuses',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/event/:event_key/teams/statuses")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/event/:event_key/teams/statuses',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams/statuses',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/event/:event_key/teams/statuses');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/event/:event_key/teams/statuses',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/event/:event_key/teams/statuses';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/event/:event_key/teams/statuses"]
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}}/event/:event_key/teams/statuses" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/event/:event_key/teams/statuses",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/event/:event_key/teams/statuses', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/event/:event_key/teams/statuses');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/event/:event_key/teams/statuses');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/event/:event_key/teams/statuses' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/event/:event_key/teams/statuses' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/event/:event_key/teams/statuses", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/event/:event_key/teams/statuses"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/event/:event_key/teams/statuses"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/event/:event_key/teams/statuses")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/event/:event_key/teams/statuses') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/event/:event_key/teams/statuses";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/event/:event_key/teams/statuses \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/event/:event_key/teams/statuses \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/event/:event_key/teams/statusesimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/event/:event_key/teams/statuses")! 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
getEventsByYear
{{baseUrl}}/events/:year
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/events/:year");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/events/:year" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/events/:year"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/events/:year"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/events/:year");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/events/:year"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/events/:year HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/events/:year")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/events/:year"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/events/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/events/:year")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/events/:year');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/events/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/events/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/events/:year',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/events/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/events/:year',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/events/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/events/:year');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/events/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/events/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/events/:year"]
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}}/events/:year" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/events/:year",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/events/:year', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/events/:year');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/events/:year');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/events/:year' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/events/:year' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/events/:year", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/events/:year"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/events/:year"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/events/:year")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/events/:year') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/events/:year";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/events/:year \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/events/:year \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/events/:yearimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/events/:year")! 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
getEventsByYearKeys
{{baseUrl}}/events/:year/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/events/:year/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/events/:year/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/events/:year/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/events/:year/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/events/:year/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/events/:year/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/events/:year/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/events/:year/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/events/:year/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/events/:year/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/events/:year/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/events/:year/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/events/:year/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/events/:year/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/events/:year/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/events/:year/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/events/:year/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/events/:year/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/events/:year/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/events/:year/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/events/:year/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/events/:year/keys"]
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}}/events/:year/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/events/:year/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/events/:year/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/events/:year/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/events/:year/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/events/:year/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/events/:year/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/events/:year/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/events/:year/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/events/:year/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/events/:year/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/events/:year/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/events/:year/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/events/:year/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/events/:year/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/events/:year/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/events/:year/keys")! 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
getEventsByYearSimple
{{baseUrl}}/events/:year/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/events/:year/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/events/:year/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/events/:year/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/events/:year/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/events/:year/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/events/:year/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/events/:year/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/events/:year/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/events/:year/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/events/:year/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/events/:year/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/events/:year/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/events/:year/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/events/:year/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/events/:year/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/events/:year/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/events/:year/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/events/:year/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/events/:year/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/events/:year/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/events/:year/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/events/:year/simple"]
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}}/events/:year/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/events/:year/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/events/:year/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/events/:year/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/events/:year/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/events/:year/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/events/:year/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/events/:year/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/events/:year/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/events/:year/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/events/:year/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/events/:year/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/events/:year/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/events/:year/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/events/:year/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/events/:year/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/events/:year/simple")! 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
getTeamEventsStatusesByYear
{{baseUrl}}/team/:team_key/events/:year/statuses
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/events/:year/statuses");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/events/:year/statuses" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/events/:year/statuses"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/events/:year/statuses"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/events/:year/statuses");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/events/:year/statuses"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/events/:year/statuses HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/events/:year/statuses")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/events/:year/statuses"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/:year/statuses")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/events/:year/statuses")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/events/:year/statuses');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year/statuses',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/events/:year/statuses';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/events/:year/statuses',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/:year/statuses")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/events/:year/statuses',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year/statuses',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/events/:year/statuses');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year/statuses',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/events/:year/statuses';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/events/:year/statuses"]
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}}/team/:team_key/events/:year/statuses" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/events/:year/statuses",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/events/:year/statuses', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/events/:year/statuses');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/events/:year/statuses');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/events/:year/statuses' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/events/:year/statuses' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/events/:year/statuses", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/events/:year/statuses"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/events/:year/statuses"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/events/:year/statuses")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/events/:year/statuses') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/events/:year/statuses";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/events/:year/statuses \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/events/:year/statuses \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/events/:year/statusesimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/events/:year/statuses")! 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
getMatch
{{baseUrl}}/match/:match_key
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
match_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/match/:match_key");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/match/:match_key" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/match/:match_key"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/match/:match_key"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/match/:match_key");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/match/:match_key"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/match/:match_key HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/match/:match_key")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/match/:match_key"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/match/:match_key")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/match/:match_key")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/match/:match_key');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/match/:match_key';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/match/:match_key',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/match/:match_key")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/match/:match_key',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/match/:match_key');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/match/:match_key';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/match/:match_key"]
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}}/match/:match_key" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/match/:match_key",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/match/:match_key', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/match/:match_key');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/match/:match_key');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/match/:match_key' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/match/:match_key' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/match/:match_key", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/match/:match_key"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/match/:match_key"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/match/:match_key")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/match/:match_key') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/match/:match_key";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/match/:match_key \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/match/:match_key \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/match/:match_keyimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/match/:match_key")! 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
getMatchSimple
{{baseUrl}}/match/:match_key/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
match_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/match/:match_key/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/match/:match_key/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/match/:match_key/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/match/:match_key/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/match/:match_key/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/match/:match_key/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/match/:match_key/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/match/:match_key/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/match/:match_key/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/match/:match_key/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/match/:match_key/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/match/:match_key/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/match/:match_key/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/match/:match_key/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/match/:match_key/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/match/:match_key/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/match/:match_key/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/match/:match_key/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/match/:match_key/simple"]
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}}/match/:match_key/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/match/:match_key/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/match/:match_key/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/match/:match_key/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/match/:match_key/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/match/:match_key/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/match/:match_key/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/match/:match_key/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/match/:match_key/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/match/:match_key/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/match/:match_key/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/match/:match_key/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/match/:match_key/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/match/:match_key/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/match/:match_key/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/match/:match_key/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/match/:match_key/simple")! 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
getMatchTimeseries
{{baseUrl}}/match/:match_key/timeseries
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
match_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/match/:match_key/timeseries");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/match/:match_key/timeseries" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/match/:match_key/timeseries"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/match/:match_key/timeseries"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/match/:match_key/timeseries");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/match/:match_key/timeseries"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/match/:match_key/timeseries HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/match/:match_key/timeseries")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/match/:match_key/timeseries"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/match/:match_key/timeseries")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/match/:match_key/timeseries")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/match/:match_key/timeseries');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key/timeseries',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/match/:match_key/timeseries';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/match/:match_key/timeseries',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/match/:match_key/timeseries")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/match/:match_key/timeseries',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key/timeseries',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/match/:match_key/timeseries');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key/timeseries',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/match/:match_key/timeseries';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/match/:match_key/timeseries"]
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}}/match/:match_key/timeseries" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/match/:match_key/timeseries",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/match/:match_key/timeseries', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/match/:match_key/timeseries');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/match/:match_key/timeseries');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/match/:match_key/timeseries' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/match/:match_key/timeseries' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/match/:match_key/timeseries", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/match/:match_key/timeseries"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/match/:match_key/timeseries"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/match/:match_key/timeseries")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/match/:match_key/timeseries') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/match/:match_key/timeseries";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/match/:match_key/timeseries \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/match/:match_key/timeseries \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/match/:match_key/timeseriesimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/match/:match_key/timeseries")! 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
getMatchZebra
{{baseUrl}}/match/:match_key/zebra_motionworks
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
match_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/match/:match_key/zebra_motionworks");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/match/:match_key/zebra_motionworks" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/match/:match_key/zebra_motionworks"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/match/:match_key/zebra_motionworks"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/match/:match_key/zebra_motionworks");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/match/:match_key/zebra_motionworks"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/match/:match_key/zebra_motionworks HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/match/:match_key/zebra_motionworks")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/match/:match_key/zebra_motionworks"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/match/:match_key/zebra_motionworks")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/match/:match_key/zebra_motionworks")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/match/:match_key/zebra_motionworks');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key/zebra_motionworks',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/match/:match_key/zebra_motionworks';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/match/:match_key/zebra_motionworks',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/match/:match_key/zebra_motionworks")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/match/:match_key/zebra_motionworks',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key/zebra_motionworks',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/match/:match_key/zebra_motionworks');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/match/:match_key/zebra_motionworks',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/match/:match_key/zebra_motionworks';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/match/:match_key/zebra_motionworks"]
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}}/match/:match_key/zebra_motionworks" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/match/:match_key/zebra_motionworks",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/match/:match_key/zebra_motionworks', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/match/:match_key/zebra_motionworks');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/match/:match_key/zebra_motionworks');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/match/:match_key/zebra_motionworks' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/match/:match_key/zebra_motionworks' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/match/:match_key/zebra_motionworks", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/match/:match_key/zebra_motionworks"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/match/:match_key/zebra_motionworks"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/match/:match_key/zebra_motionworks")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/match/:match_key/zebra_motionworks') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/match/:match_key/zebra_motionworks";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/match/:match_key/zebra_motionworks \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/match/:match_key/zebra_motionworks \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/match/:match_key/zebra_motionworksimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/match/:match_key/zebra_motionworks")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"times": [
[
0,
0.1,
0.2
]
]
}
GET
getStatus
{{baseUrl}}/status
HEADERS
X-TBA-Auth-Key
{{apiKey}}
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/status");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/status" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/status"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/status"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/status");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/status"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/status HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/status")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/status"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/status")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/status")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/status');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/status',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/status';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/status',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/status")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/status',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/status',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/status');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/status',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/status';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/status"]
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}}/status" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/status",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/status', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/status');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/status');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/status' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/status' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/status", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/status"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/status"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/status")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/status') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/status";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/status \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/status \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/statusimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/status")! 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
getTeam
{{baseUrl}}/team/:team_key
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key"]
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}}/team/:team_key" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_keyimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key")! 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
getTeamAwards
{{baseUrl}}/team/:team_key/awards
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/awards");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/awards" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/awards"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/awards"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/awards");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/awards"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/awards HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/awards")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/awards"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/awards")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/awards")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/awards');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/awards',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/awards';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/awards',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/awards")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/awards',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/awards',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/awards');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/awards',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/awards';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/awards"]
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}}/team/:team_key/awards" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/awards",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/awards', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/awards');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/awards');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/awards' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/awards' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/awards", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/awards"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/awards"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/awards")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/awards') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/awards";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/awards \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/awards \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/awardsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/awards")! 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
getTeamAwardsByYear
{{baseUrl}}/team/:team_key/awards/:year
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/awards/:year");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/awards/:year" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/awards/:year"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/awards/:year"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/awards/:year");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/awards/:year"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/awards/:year HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/awards/:year")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/awards/:year"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/awards/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/awards/:year")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/awards/:year');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/awards/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/awards/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/awards/:year',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/awards/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/awards/:year',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/awards/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/awards/:year');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/awards/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/awards/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/awards/:year"]
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}}/team/:team_key/awards/:year" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/awards/:year",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/awards/:year', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/awards/:year');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/awards/:year');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/awards/:year' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/awards/:year' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/awards/:year", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/awards/:year"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/awards/:year"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/awards/:year")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/awards/:year') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/awards/:year";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/awards/:year \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/awards/:year \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/awards/:yearimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/awards/:year")! 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
getTeamDistricts
{{baseUrl}}/team/:team_key/districts
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/districts");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/districts" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/districts"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/districts"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/districts");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/districts"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/districts HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/districts")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/districts"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/districts")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/districts")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/districts');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/districts',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/districts';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/districts',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/districts")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/districts',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/districts',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/districts');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/districts',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/districts';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/districts"]
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}}/team/:team_key/districts" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/districts",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/districts', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/districts');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/districts');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/districts' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/districts' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/districts", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/districts"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/districts"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/districts")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/districts') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/districts";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/districts \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/districts \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/districtsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/districts")! 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
getTeamEventAwards
{{baseUrl}}/team/:team_key/event/:event_key/awards
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/event/:event_key/awards");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/event/:event_key/awards" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/event/:event_key/awards"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/event/:event_key/awards"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/event/:event_key/awards");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/event/:event_key/awards"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/event/:event_key/awards HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/event/:event_key/awards")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/event/:event_key/awards"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/awards")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/event/:event_key/awards")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/event/:event_key/awards');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/awards',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/event/:event_key/awards';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/event/:event_key/awards',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/awards")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/event/:event_key/awards',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/awards',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/event/:event_key/awards');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/awards',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/event/:event_key/awards';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/event/:event_key/awards"]
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}}/team/:team_key/event/:event_key/awards" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/event/:event_key/awards",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/event/:event_key/awards', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/event/:event_key/awards');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/event/:event_key/awards');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/event/:event_key/awards' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/event/:event_key/awards' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/event/:event_key/awards", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/event/:event_key/awards"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/event/:event_key/awards"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/event/:event_key/awards")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/event/:event_key/awards') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/event/:event_key/awards";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/event/:event_key/awards \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/event/:event_key/awards \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/event/:event_key/awardsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/event/:event_key/awards")! 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
getTeamEventMatches
{{baseUrl}}/team/:team_key/event/:event_key/matches
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/event/:event_key/matches");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/event/:event_key/matches" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/event/:event_key/matches"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/event/:event_key/matches"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/event/:event_key/matches");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/event/:event_key/matches"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/event/:event_key/matches HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/event/:event_key/matches")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/event/:event_key/matches"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/matches")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/event/:event_key/matches")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/event/:event_key/matches');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/event/:event_key/matches';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/matches")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/event/:event_key/matches',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/event/:event_key/matches');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/event/:event_key/matches';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/event/:event_key/matches"]
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}}/team/:team_key/event/:event_key/matches" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/event/:event_key/matches",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/event/:event_key/matches', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/event/:event_key/matches');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/event/:event_key/matches');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/event/:event_key/matches' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/event/:event_key/matches' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/event/:event_key/matches", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/event/:event_key/matches"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/event/:event_key/matches"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/event/:event_key/matches")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/event/:event_key/matches') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/event/:event_key/matches";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/event/:event_key/matches \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/event/:event_key/matches \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/event/:event_key/matchesimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/event/:event_key/matches")! 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
getTeamEventMatchesKeys
{{baseUrl}}/team/:team_key/event/:event_key/matches/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/event/:event_key/matches/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/event/:event_key/matches/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/event/:event_key/matches/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/event/:event_key/matches/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/matches/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/event/:event_key/matches/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/matches/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/event/:event_key/matches/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/event/:event_key/matches/keys"]
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}}/team/:team_key/event/:event_key/matches/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/event/:event_key/matches/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/event/:event_key/matches/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/event/:event_key/matches/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/event/:event_key/matches/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/event/:event_key/matches/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/event/:event_key/matches/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/event/:event_key/matches/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/event/:event_key/matches/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/event/:event_key/matches/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/event/:event_key/matches/keys")! 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
getTeamEventMatchesSimple
{{baseUrl}}/team/:team_key/event/:event_key/matches/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/event/:event_key/matches/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/event/:event_key/matches/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/event/:event_key/matches/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/event/:event_key/matches/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/matches/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/event/:event_key/matches/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/matches/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/event/:event_key/matches/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/event/:event_key/matches/simple"]
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}}/team/:team_key/event/:event_key/matches/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/event/:event_key/matches/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/event/:event_key/matches/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/event/:event_key/matches/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/event/:event_key/matches/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/event/:event_key/matches/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/event/:event_key/matches/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/event/:event_key/matches/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/event/:event_key/matches/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/event/:event_key/matches/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/event/:event_key/matches/simple")! 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
getTeamEventStatus
{{baseUrl}}/team/:team_key/event/:event_key/status
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
event_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/event/:event_key/status");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/event/:event_key/status" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/event/:event_key/status"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/event/:event_key/status"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/event/:event_key/status");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/event/:event_key/status"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/event/:event_key/status HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/event/:event_key/status")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/event/:event_key/status"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/status")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/event/:event_key/status")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/event/:event_key/status');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/status',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/event/:event_key/status';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/event/:event_key/status',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/event/:event_key/status")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/event/:event_key/status',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/status',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/event/:event_key/status');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/event/:event_key/status',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/event/:event_key/status';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/event/:event_key/status"]
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}}/team/:team_key/event/:event_key/status" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/event/:event_key/status",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/event/:event_key/status', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/event/:event_key/status');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/event/:event_key/status');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/event/:event_key/status' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/event/:event_key/status' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/event/:event_key/status", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/event/:event_key/status"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/event/:event_key/status"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/event/:event_key/status")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/event/:event_key/status') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/event/:event_key/status";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/event/:event_key/status \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/event/:event_key/status \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/event/:event_key/statusimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/event/:event_key/status")! 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
getTeamEvents
{{baseUrl}}/team/:team_key/events
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/events");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/events" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/events"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/events"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/events");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/events"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/events HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/events")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/events"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/events")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/events")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/events');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/events';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/events',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/events")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/events',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/events');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/events';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/events"]
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}}/team/:team_key/events" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/events",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/events', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/events');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/events');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/events' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/events' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/events", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/events"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/events"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/events")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/events') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/events";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/events \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/events \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/eventsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/events")! 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
getTeamEventsByYear
{{baseUrl}}/team/:team_key/events/:year
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/events/:year");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/events/:year" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/events/:year"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/events/:year"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/events/:year");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/events/:year"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/events/:year HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/events/:year")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/events/:year"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/events/:year")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/events/:year');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/events/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/events/:year',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/events/:year',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/events/:year');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/events/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/events/:year"]
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}}/team/:team_key/events/:year" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/events/:year",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/events/:year', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/events/:year');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/events/:year');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/events/:year' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/events/:year' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/events/:year", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/events/:year"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/events/:year"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/events/:year")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/events/:year') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/events/:year";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/events/:year \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/events/:year \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/events/:yearimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/events/:year")! 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
getTeamEventsByYearKeys
{{baseUrl}}/team/:team_key/events/:year/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/events/:year/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/events/:year/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/events/:year/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/events/:year/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/events/:year/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/events/:year/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/events/:year/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/events/:year/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/events/:year/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/:year/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/events/:year/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/events/:year/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/events/:year/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/events/:year/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/:year/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/events/:year/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/events/:year/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/events/:year/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/events/:year/keys"]
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}}/team/:team_key/events/:year/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/events/:year/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/events/:year/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/events/:year/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/events/:year/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/events/:year/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/events/:year/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/events/:year/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/events/:year/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/events/:year/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/events/:year/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/events/:year/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/events/:year/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/events/:year/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/events/:year/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/events/:year/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/events/:year/keys")! 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
getTeamEventsByYearSimple
{{baseUrl}}/team/:team_key/events/:year/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/events/:year/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/events/:year/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/events/:year/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/events/:year/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/events/:year/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/events/:year/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/events/:year/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/events/:year/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/events/:year/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/:year/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/events/:year/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/events/:year/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/events/:year/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/events/:year/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/:year/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/events/:year/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/events/:year/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/:year/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/events/:year/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/events/:year/simple"]
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}}/team/:team_key/events/:year/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/events/:year/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/events/:year/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/events/:year/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/events/:year/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/events/:year/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/events/:year/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/events/:year/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/events/:year/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/events/:year/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/events/:year/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/events/:year/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/events/:year/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/events/:year/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/events/:year/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/events/:year/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/events/:year/simple")! 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
getTeamEventsKeys
{{baseUrl}}/team/:team_key/events/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/events/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/events/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/events/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/events/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/events/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/events/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/events/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/events/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/events/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/events/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/events/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/events/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/events/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/events/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/events/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/events/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/events/keys"]
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}}/team/:team_key/events/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/events/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/events/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/events/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/events/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/events/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/events/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/events/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/events/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/events/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/events/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/events/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/events/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/events/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/events/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/events/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/events/keys")! 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
getTeamEventsSimple
{{baseUrl}}/team/:team_key/events/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/events/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/events/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/events/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/events/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/events/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/events/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/events/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/events/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/events/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/events/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/events/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/events/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/events/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/events/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/events/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/events/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/events/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/events/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/events/simple"]
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}}/team/:team_key/events/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/events/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/events/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/events/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/events/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/events/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/events/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/events/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/events/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/events/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/events/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/events/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/events/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/events/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/events/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/events/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/events/simple")! 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
getTeamMatchesByYear
{{baseUrl}}/team/:team_key/matches/:year
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/matches/:year");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/matches/:year" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/matches/:year"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/matches/:year"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/matches/:year");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/matches/:year"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/matches/:year HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/matches/:year")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/matches/:year"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/matches/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/matches/:year")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/matches/:year');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/matches/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/matches/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/matches/:year',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/matches/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/matches/:year',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/matches/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/matches/:year');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/matches/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/matches/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/matches/:year"]
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}}/team/:team_key/matches/:year" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/matches/:year",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/matches/:year', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/matches/:year');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/matches/:year');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/matches/:year' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/matches/:year' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/matches/:year", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/matches/:year"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/matches/:year"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/matches/:year")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/matches/:year') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/matches/:year";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/matches/:year \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/matches/:year \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/matches/:yearimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/matches/:year")! 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
getTeamMatchesByYearKeys
{{baseUrl}}/team/:team_key/matches/:year/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/matches/:year/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/matches/:year/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/matches/:year/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/matches/:year/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/matches/:year/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/matches/:year/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/matches/:year/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/matches/:year/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/matches/:year/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/matches/:year/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/matches/:year/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/matches/:year/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/matches/:year/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/matches/:year/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/matches/:year/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/matches/:year/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/matches/:year/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/matches/:year/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/matches/:year/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/matches/:year/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/matches/:year/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/matches/:year/keys"]
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}}/team/:team_key/matches/:year/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/matches/:year/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/matches/:year/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/matches/:year/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/matches/:year/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/matches/:year/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/matches/:year/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/matches/:year/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/matches/:year/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/matches/:year/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/matches/:year/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/matches/:year/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/matches/:year/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/matches/:year/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/matches/:year/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/matches/:year/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/matches/:year/keys")! 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
getTeamMatchesByYearSimple
{{baseUrl}}/team/:team_key/matches/:year/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/matches/:year/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/matches/:year/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/matches/:year/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/matches/:year/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/matches/:year/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/matches/:year/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/matches/:year/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/matches/:year/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/matches/:year/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/matches/:year/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/matches/:year/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/matches/:year/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/matches/:year/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/matches/:year/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/matches/:year/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/matches/:year/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/matches/:year/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/matches/:year/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/matches/:year/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/matches/:year/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/matches/:year/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/matches/:year/simple"]
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}}/team/:team_key/matches/:year/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/matches/:year/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/matches/:year/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/matches/:year/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/matches/:year/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/matches/:year/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/matches/:year/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/matches/:year/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/matches/:year/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/matches/:year/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/matches/:year/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/matches/:year/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/matches/:year/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/matches/:year/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/matches/:year/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/matches/:year/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/matches/:year/simple")! 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
getTeamMediaByTag
{{baseUrl}}/team/:team_key/media/tag/:media_tag
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
media_tag
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/media/tag/:media_tag");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/media/tag/:media_tag" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/media/tag/:media_tag"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/media/tag/:media_tag"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/media/tag/:media_tag");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/media/tag/:media_tag"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/media/tag/:media_tag HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/media/tag/:media_tag")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/media/tag/:media_tag"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/media/tag/:media_tag")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/media/tag/:media_tag")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/media/tag/:media_tag');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/media/tag/:media_tag',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/media/tag/:media_tag';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/media/tag/:media_tag',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/media/tag/:media_tag")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/media/tag/:media_tag',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/media/tag/:media_tag',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/media/tag/:media_tag');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/media/tag/:media_tag',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/media/tag/:media_tag';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/media/tag/:media_tag"]
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}}/team/:team_key/media/tag/:media_tag" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/media/tag/:media_tag",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/media/tag/:media_tag', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/media/tag/:media_tag');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/media/tag/:media_tag');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/media/tag/:media_tag' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/media/tag/:media_tag' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/media/tag/:media_tag", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/media/tag/:media_tag"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/media/tag/:media_tag"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/media/tag/:media_tag")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/media/tag/:media_tag') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/media/tag/:media_tag";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/media/tag/:media_tag \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/media/tag/:media_tag \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/media/tag/:media_tagimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/media/tag/:media_tag")! 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
getTeamMediaByTagYear
{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
media_tag
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/media/tag/:media_tag/:year"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/media/tag/:media_tag/:year HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/media/tag/:media_tag/:year',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year"]
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}}/team/:team_key/media/tag/:media_tag/:year" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/media/tag/:media_tag/:year", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/media/tag/:media_tag/:year') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/media/tag/:media_tag/:year \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/media/tag/:media_tag/:year \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/media/tag/:media_tag/:yearimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/media/tag/:media_tag/:year")! 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
getTeamMediaByYear
{{baseUrl}}/team/:team_key/media/:year
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
year
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/media/:year");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/media/:year" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/media/:year"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/media/:year"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/media/:year");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/media/:year"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/media/:year HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/media/:year")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/media/:year"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/media/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/media/:year")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/media/:year');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/media/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/media/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/media/:year',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/media/:year")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/media/:year',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/media/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/media/:year');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/media/:year',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/media/:year';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/media/:year"]
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}}/team/:team_key/media/:year" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/media/:year",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/media/:year', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/media/:year');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/media/:year');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/media/:year' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/media/:year' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/media/:year", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/media/:year"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/media/:year"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/media/:year")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/media/:year') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/media/:year";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/media/:year \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/media/:year \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/media/:yearimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/media/:year")! 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
getTeamRobots
{{baseUrl}}/team/:team_key/robots
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/robots");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/robots" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/robots"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/robots"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/robots");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/robots"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/robots HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/robots")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/robots"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/robots")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/robots")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/robots');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/robots',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/robots';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/robots',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/robots")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/robots',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/robots',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/robots');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/robots',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/robots';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/robots"]
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}}/team/:team_key/robots" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/robots",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/robots', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/robots');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/robots');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/robots' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/robots' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/robots", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/robots"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/robots"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/robots")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/robots') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/robots";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/robots \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/robots \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/robotsimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/robots")! 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
getTeamSimple
{{baseUrl}}/team/:team_key/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/simple"]
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}}/team/:team_key/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/simple")! 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
getTeamSocialMedia
{{baseUrl}}/team/:team_key/social_media
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/social_media");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/social_media" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/social_media"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/social_media"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/social_media");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/social_media"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/social_media HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/social_media")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/social_media"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/social_media")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/social_media")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/social_media');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/social_media',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/social_media';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/social_media',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/social_media")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/social_media',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/social_media',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/social_media');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/social_media',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/social_media';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/social_media"]
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}}/team/:team_key/social_media" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/social_media",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/social_media', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/social_media');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/social_media');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/social_media' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/social_media' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/social_media", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/social_media"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/social_media"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/social_media")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/social_media') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/social_media";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/social_media \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/social_media \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/social_mediaimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/social_media")! 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
getTeamYearsParticipated
{{baseUrl}}/team/:team_key/years_participated
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
team_key
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/team/:team_key/years_participated");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/team/:team_key/years_participated" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/team/:team_key/years_participated"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/team/:team_key/years_participated"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/team/:team_key/years_participated");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/team/:team_key/years_participated"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/team/:team_key/years_participated HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/team/:team_key/years_participated")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/team/:team_key/years_participated"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/team/:team_key/years_participated")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/team/:team_key/years_participated")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/team/:team_key/years_participated');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/years_participated',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/team/:team_key/years_participated';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/team/:team_key/years_participated',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/team/:team_key/years_participated")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/team/:team_key/years_participated',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/years_participated',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/team/:team_key/years_participated');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/team/:team_key/years_participated',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/team/:team_key/years_participated';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/team/:team_key/years_participated"]
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}}/team/:team_key/years_participated" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/team/:team_key/years_participated",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/team/:team_key/years_participated', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/team/:team_key/years_participated');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/team/:team_key/years_participated');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/team/:team_key/years_participated' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/team/:team_key/years_participated' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/team/:team_key/years_participated", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/team/:team_key/years_participated"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/team/:team_key/years_participated"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/team/:team_key/years_participated")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/team/:team_key/years_participated') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/team/:team_key/years_participated";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/team/:team_key/years_participated \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/team/:team_key/years_participated \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/team/:team_key/years_participatedimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/team/:team_key/years_participated")! 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
getTeams
{{baseUrl}}/teams/:page_num
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
page_num
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/teams/:page_num");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/teams/:page_num" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/teams/:page_num"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/teams/:page_num"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/teams/:page_num");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/teams/:page_num"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/teams/:page_num HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/teams/:page_num")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/teams/:page_num"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/teams/:page_num")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/teams/:page_num")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/teams/:page_num');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:page_num',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/teams/:page_num';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/teams/:page_num',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/teams/:page_num")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/teams/:page_num',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:page_num',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/teams/:page_num');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:page_num',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/teams/:page_num';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/teams/:page_num"]
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}}/teams/:page_num" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/teams/:page_num",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/teams/:page_num', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/teams/:page_num');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/teams/:page_num');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/teams/:page_num' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/teams/:page_num' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/teams/:page_num", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/teams/:page_num"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/teams/:page_num"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/teams/:page_num")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/teams/:page_num') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/teams/:page_num";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/teams/:page_num \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/teams/:page_num \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/teams/:page_numimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/teams/:page_num")! 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
getTeamsByYear
{{baseUrl}}/teams/:year/:page_num
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
year
page_num
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/teams/:year/:page_num");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/teams/:year/:page_num" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/teams/:year/:page_num"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/teams/:year/:page_num"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/teams/:year/:page_num");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/teams/:year/:page_num"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/teams/:year/:page_num HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/teams/:year/:page_num")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/teams/:year/:page_num"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/teams/:year/:page_num")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/teams/:year/:page_num")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/teams/:year/:page_num');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:year/:page_num',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/teams/:year/:page_num';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/teams/:year/:page_num',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/teams/:year/:page_num")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/teams/:year/:page_num',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:year/:page_num',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/teams/:year/:page_num');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:year/:page_num',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/teams/:year/:page_num';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/teams/:year/:page_num"]
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}}/teams/:year/:page_num" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/teams/:year/:page_num",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/teams/:year/:page_num', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/teams/:year/:page_num');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/teams/:year/:page_num');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/teams/:year/:page_num' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/teams/:year/:page_num' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/teams/:year/:page_num", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/teams/:year/:page_num"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/teams/:year/:page_num"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/teams/:year/:page_num")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/teams/:year/:page_num') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/teams/:year/:page_num";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/teams/:year/:page_num \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/teams/:year/:page_num \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/teams/:year/:page_numimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/teams/:year/:page_num")! 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
getTeamsByYearKeys
{{baseUrl}}/teams/:year/:page_num/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
year
page_num
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/teams/:year/:page_num/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/teams/:year/:page_num/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/teams/:year/:page_num/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/teams/:year/:page_num/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/teams/:year/:page_num/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/teams/:year/:page_num/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/teams/:year/:page_num/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/teams/:year/:page_num/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/teams/:year/:page_num/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/teams/:year/:page_num/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/teams/:year/:page_num/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/teams/:year/:page_num/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:year/:page_num/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/teams/:year/:page_num/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/teams/:year/:page_num/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/teams/:year/:page_num/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/teams/:year/:page_num/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:year/:page_num/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/teams/:year/:page_num/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:year/:page_num/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/teams/:year/:page_num/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/teams/:year/:page_num/keys"]
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}}/teams/:year/:page_num/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/teams/:year/:page_num/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/teams/:year/:page_num/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/teams/:year/:page_num/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/teams/:year/:page_num/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/teams/:year/:page_num/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/teams/:year/:page_num/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/teams/:year/:page_num/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/teams/:year/:page_num/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/teams/:year/:page_num/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/teams/:year/:page_num/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/teams/:year/:page_num/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/teams/:year/:page_num/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/teams/:year/:page_num/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/teams/:year/:page_num/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/teams/:year/:page_num/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/teams/:year/:page_num/keys")! 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
getTeamsByYearSimple
{{baseUrl}}/teams/:year/:page_num/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
year
page_num
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/teams/:year/:page_num/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/teams/:year/:page_num/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/teams/:year/:page_num/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/teams/:year/:page_num/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/teams/:year/:page_num/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/teams/:year/:page_num/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/teams/:year/:page_num/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/teams/:year/:page_num/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/teams/:year/:page_num/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/teams/:year/:page_num/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/teams/:year/:page_num/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/teams/:year/:page_num/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:year/:page_num/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/teams/:year/:page_num/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/teams/:year/:page_num/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/teams/:year/:page_num/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/teams/:year/:page_num/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:year/:page_num/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/teams/:year/:page_num/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:year/:page_num/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/teams/:year/:page_num/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/teams/:year/:page_num/simple"]
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}}/teams/:year/:page_num/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/teams/:year/:page_num/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/teams/:year/:page_num/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/teams/:year/:page_num/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/teams/:year/:page_num/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/teams/:year/:page_num/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/teams/:year/:page_num/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/teams/:year/:page_num/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/teams/:year/:page_num/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/teams/:year/:page_num/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/teams/:year/:page_num/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/teams/:year/:page_num/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/teams/:year/:page_num/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/teams/:year/:page_num/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/teams/:year/:page_num/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/teams/:year/:page_num/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/teams/:year/:page_num/simple")! 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
getTeamsKeys
{{baseUrl}}/teams/:page_num/keys
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
page_num
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/teams/:page_num/keys");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/teams/:page_num/keys" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/teams/:page_num/keys"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/teams/:page_num/keys"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/teams/:page_num/keys");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/teams/:page_num/keys"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/teams/:page_num/keys HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/teams/:page_num/keys")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/teams/:page_num/keys"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/teams/:page_num/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/teams/:page_num/keys")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/teams/:page_num/keys');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:page_num/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/teams/:page_num/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/teams/:page_num/keys',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/teams/:page_num/keys")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/teams/:page_num/keys',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:page_num/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/teams/:page_num/keys');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:page_num/keys',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/teams/:page_num/keys';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/teams/:page_num/keys"]
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}}/teams/:page_num/keys" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/teams/:page_num/keys",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/teams/:page_num/keys', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/teams/:page_num/keys');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/teams/:page_num/keys');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/teams/:page_num/keys' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/teams/:page_num/keys' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/teams/:page_num/keys", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/teams/:page_num/keys"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/teams/:page_num/keys"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/teams/:page_num/keys")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/teams/:page_num/keys') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/teams/:page_num/keys";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/teams/:page_num/keys \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/teams/:page_num/keys \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/teams/:page_num/keysimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/teams/:page_num/keys")! 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
getTeamsSimple
{{baseUrl}}/teams/:page_num/simple
HEADERS
X-TBA-Auth-Key
{{apiKey}}
QUERY PARAMS
page_num
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/teams/:page_num/simple");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-tba-auth-key: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/teams/:page_num/simple" {:headers {:x-tba-auth-key "{{apiKey}}"}})require "http/client"
url = "{{baseUrl}}/teams/:page_num/simple"
headers = HTTP::Headers{
"x-tba-auth-key" => "{{apiKey}}"
}
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}}/teams/:page_num/simple"),
Headers =
{
{ "x-tba-auth-key", "{{apiKey}}" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/teams/:page_num/simple");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-tba-auth-key", "{{apiKey}}");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/teams/:page_num/simple"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-tba-auth-key", "{{apiKey}}")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/teams/:page_num/simple HTTP/1.1
X-Tba-Auth-Key: {{apiKey}}
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/teams/:page_num/simple")
.setHeader("x-tba-auth-key", "{{apiKey}}")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/teams/:page_num/simple"))
.header("x-tba-auth-key", "{{apiKey}}")
.method("GET", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/teams/:page_num/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/teams/:page_num/simple")
.header("x-tba-auth-key", "{{apiKey}}")
.asString(); const data = null;
const xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener('readystatechange', function () {
if (this.readyState === this.DONE) {
console.log(this.responseText);
}
});
xhr.open('GET', '{{baseUrl}}/teams/:page_num/simple');
xhr.setRequestHeader('x-tba-auth-key', '{{apiKey}}');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:page_num/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/teams/:page_num/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}const settings = {
async: true,
crossDomain: true,
url: '{{baseUrl}}/teams/:page_num/simple',
method: 'GET',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/teams/:page_num/simple")
.get()
.addHeader("x-tba-auth-key", "{{apiKey}}")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/teams/:page_num/simple',
headers: {
'x-tba-auth-key': '{{apiKey}}'
}
};
const req = http.request(options, function (res) {
const chunks = [];
res.on('data', function (chunk) {
chunks.push(chunk);
});
res.on('end', function () {
const body = Buffer.concat(chunks);
console.log(body.toString());
});
});
req.end();const request = require('request');
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:page_num/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/teams/:page_num/simple');
req.headers({
'x-tba-auth-key': '{{apiKey}}'
});
req.end(function (res) {
if (res.error) throw new Error(res.error);
console.log(res.body);
});const axios = require('axios').default;
const options = {
method: 'GET',
url: '{{baseUrl}}/teams/:page_num/simple',
headers: {'x-tba-auth-key': '{{apiKey}}'}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/teams/:page_num/simple';
const options = {method: 'GET', headers: {'x-tba-auth-key': '{{apiKey}}'}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-tba-auth-key": @"{{apiKey}}" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/teams/:page_num/simple"]
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}}/teams/:page_num/simple" in
let headers = Header.add (Header.init ()) "x-tba-auth-key" "{{apiKey}}" in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/teams/:page_num/simple",
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-tba-auth-key: {{apiKey}}"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/teams/:page_num/simple', [
'headers' => [
'x-tba-auth-key' => '{{apiKey}}',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/teams/:page_num/simple');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/teams/:page_num/simple');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-tba-auth-key' => '{{apiKey}}'
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/teams/:page_num/simple' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-tba-auth-key", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/teams/:page_num/simple' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-tba-auth-key': "{{apiKey}}" }
conn.request("GET", "/baseUrl/teams/:page_num/simple", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/teams/:page_num/simple"
headers = {"x-tba-auth-key": "{{apiKey}}"}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/teams/:page_num/simple"
response <- VERB("GET", url, add_headers('x-tba-auth-key' = '{{apiKey}}'), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/teams/:page_num/simple")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-tba-auth-key"] = '{{apiKey}}'
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/teams/:page_num/simple') do |req|
req.headers['x-tba-auth-key'] = '{{apiKey}}'
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/teams/:page_num/simple";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-tba-auth-key", "{{apiKey}}".parse().unwrap());
let client = reqwest::Client::new();
let response = client.get(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request GET \
--url {{baseUrl}}/teams/:page_num/simple \
--header 'x-tba-auth-key: {{apiKey}}'http GET {{baseUrl}}/teams/:page_num/simple \
x-tba-auth-key:'{{apiKey}}'wget --quiet \
--method GET \
--header 'x-tba-auth-key: {{apiKey}}' \
--output-document \
- {{baseUrl}}/teams/:page_num/simpleimport Foundation
let headers = ["x-tba-auth-key": "{{apiKey}}"]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/teams/:page_num/simple")! 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()