Nookipedia
Nookipediav1.5.0
The Nookipedia API provides endpoints for retrieving Animal Crossing data pulled from the Nookipedia wiki. A couple of the key benefits of using the Nookipedia API is access to data spanning the entire Animal Crossing series, as well as information that is constantly updated and expanding as editors work on the wiki. Access to the Nookipedia API requires obtaining a key. This is so we can manage our scale and provide better support for our users. To request access to the API, please fill out this form. This API is 'version 2' of our original API. While the previous API scraped information…
- Endpoints
- 30 (30 GET)
- Base URL
https://api.nookipedia.com/- Authentication
- Not specified in spec
- Spec format
- OpenAPI 3.0.0
- API version
- 1.5.0
- Source
- api.nookipedia.com
- Provider
- dodo.ac
- 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://api.nookipedia.com/), then send requests.
GET
All New Horizons artwork
{{baseUrl}}/nh/art
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/art");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/art" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/art"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/art"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/art");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/art"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/art HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/art")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/art"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/art")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/art")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/art');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/art',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/art';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/art',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/art")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/art',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/art',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/art');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/art',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/art';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/art"]
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}}/nh/art" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/art",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/art', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/art');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/art');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/art' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/art' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/art", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/art"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/art"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/art")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/art') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/art";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/art \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/art \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/artimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/art")! 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
[
{
"art_name": "Vitruvian Man",
"art_style": "Pen and ink on paper",
"authenticity": "If there is a coffee stain in the top right corner, it is fake. If there is no stain, it is genuine. The forgery has a key taped to the back of the canvas.",
"author": "Leonardo da Vinci",
"availability": "Jolly Redd's Treasure Trawler",
"buy": 4980,
"description": "This drawing is based on the "ideal" human-body ratio, as stated in "De architectura." "De architectura" was a treatise by Vitruvius, an architect from the early 1st century BCE.",
"fake_image_url": "https://dodo.ac/np/images/1/13/Academic_Painting_%28Forgery%29_NH_Icon.png",
"has_fake": true,
"image_url": "https://dodo.ac/np/images/e/e8/Academic_Painting_NH_Icon.png",
"length": 1,
"name": "Academic Painting",
"sell": 1245,
"url": "https://nookipedia.com/wiki/Academic_Painting",
"width": 1,
"year": "circa 1487"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons bugs
{{baseUrl}}/nh/bugs
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/bugs");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/bugs" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/bugs"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/bugs"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/bugs");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/bugs"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/bugs HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/bugs")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/bugs"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/bugs")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/bugs")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/bugs');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/bugs',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/bugs';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/bugs',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/bugs")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/bugs',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/bugs',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/bugs');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/bugs',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/bugs';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/bugs"]
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}}/nh/bugs" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/bugs",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/bugs', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/bugs');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/bugs');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/bugs' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/bugs' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/bugs", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/bugs"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/bugs"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/bugs")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/bugs') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/bugs";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/bugs \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/bugs \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/bugsimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/bugs")! 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
[
{
"catchphrases": [
"I caught a grasshopper! They're a grass act!"
],
"image_url": "https://dodo.ac/np/images/3/37/Grasshopper_NH_Icon.png",
"location": "On the ground",
"name": "Grasshopper",
"number": 19,
"rarity": "Uncommon",
"render_url": "https://dodo.ac/np/images/1/1d/Grasshopper_NH.png",
"sell_flick": 240,
"sell_nook": 160,
"tank_length": 1,
"tank_width": 1,
"total_catch": 0,
"url": "https://nookipedia.com/wiki/Grasshopper"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons clothing
{{baseUrl}}/nh/clothing
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/clothing");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/clothing" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/clothing"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/clothing"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/clothing");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/clothing"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/clothing HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/clothing")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/clothing"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/clothing")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/clothing")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/clothing');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/clothing',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/clothing';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/clothing',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/clothing")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/clothing',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/clothing',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/clothing');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/clothing',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/clothing';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/clothing"]
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}}/nh/clothing" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/clothing",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/clothing', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/clothing');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/clothing');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/clothing' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/clothing' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/clothing", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/clothing"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/clothing"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/clothing")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/clothing') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/clothing";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/clothing \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/clothing \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/clothingimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/clothing")! 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
[
{
"availability": [
{
"from": "Able Sisters",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 490
}
],
"category": "Accessories",
"label_themes": [
"Party"
],
"name": "3D Glasses",
"notes": "",
"seasonality": "All year",
"sell": 122,
"styles": [
"Active"
],
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:3D_Glasses_(New_Horizons)",
"variation_total": 2,
"variations": [
{
"colors": [
"White",
"Colorful"
],
"image_url": "https://dodo.ac/np/images/1/15/3D_Glasses_%28White%29_NH_Icon.png",
"variation": "White"
},
{
"colors": [
"Colorful",
"Black"
],
"image_url": "https://dodo.ac/np/images/2/28/3D_Glasses_%28Black%29_NH_Icon.png",
"variation": "Black"
}
],
"version_added": "1.0.0",
"vill_equip": true
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons events
{{baseUrl}}/nh/events
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/events");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/events" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/events"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/events"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/events");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/events"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/events HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/events")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/events"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/events")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/events")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/events');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/events',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/events';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/events',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/events")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/events',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/events',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/events');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/events',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/events';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/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}}/nh/events" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/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 => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/events', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/events');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/events');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/events' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/events' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/events", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/events"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/events"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/events")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/events') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/events";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/events \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/events \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/eventsimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/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()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
[
{
"date": "2021-05-01",
"event": "May Day event begins",
"type": "Event",
"url": "https://nookipedia.com/wiki/May_Day"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons fish
{{baseUrl}}/nh/fish
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/fish");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/fish" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/fish"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/fish"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/fish");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/fish"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/fish HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/fish")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/fish"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fish")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/fish")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fish');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/fish',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/fish';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/fish',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/fish")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/fish',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/fish',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/fish');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/fish',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/fish';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/fish"]
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}}/nh/fish" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/fish",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/fish', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/fish');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/fish');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/fish' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/fish' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/fish", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/fish"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/fish"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/fish")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/fish') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/fish";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/fish \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/fish \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/fishimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/fish")! 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
[
{
"catchphrases": [
"I caught a cherry salmon! It's the perfect topper for a marlin sundae!"
],
"image_url": "https://dodo.ac/np/images/d/db/Cherry_Salmon_NH_Icon.png",
"location": "River (clifftop)",
"name": "Cherry Salmon",
"number": 27,
"rarity": "Uncommon",
"render_url": "https://dodo.ac/np/images/c/c0/Cherry_Salmon_NH.png",
"sell_cj": 1500,
"sell_nook": 1000,
"shadow_size": "Small",
"tank_length": 1,
"tank_width": 1,
"total_catch": 100,
"url": "https://nookipedia.com/wiki/Cherry Salmon"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons fossil groups or individual fossil
{{baseUrl}}/nh/fossils/all
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/fossils/all");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/fossils/all" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/fossils/all"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/fossils/all"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/fossils/all");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/fossils/all"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/fossils/all HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/fossils/all")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/fossils/all"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/all")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/fossils/all")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/all');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/fossils/all',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/fossils/all';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/fossils/all',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/fossils/all")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/fossils/all',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/fossils/all',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/fossils/all');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/fossils/all',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/fossils/all';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/fossils/all"]
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}}/nh/fossils/all" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/fossils/all",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/fossils/all', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/fossils/all');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/fossils/all');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/fossils/all' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/fossils/all' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/fossils/all", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/fossils/all"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/fossils/all"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/fossils/all")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/fossils/all') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/fossils/all";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/fossils/all \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/fossils/all \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/fossils/allimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/fossils/all")! 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
[
{
"description": "Ahem. Yes. The Spinosaurus was a very large, carnivorous dinosaur, roughly the size of a T. Rex. Unlike its more famous cousin, however, Spinosaurus seems to have spent a great deal of time in water. Similar to modern crocodiles, this creature lived on a diet of fish AND land-dwelling animals. Personally, I am simply relieved that it did not seek FLYING prey.",
"fossils": [
{
"colors": [
"Brown"
],
"hha_base": 87,
"image_url": "https://dodo.ac/np/images/7/7b/Spino_Skull_NH_Icon.png",
"interactable": true,
"length": 2,
"name": "Spino Skull",
"sell": 4000,
"url": "https://nookipedia.com/wiki/Spinosaurus",
"width": 2
},
{
"colors": [
"Brown"
],
"hha_base": 87,
"image_url": "https://dodo.ac/np/images/4/40/Spino_Tail_NH_Icon.png",
"interactable": true,
"length": 2,
"name": "Spino Tail",
"sell": 2500,
"url": "https://nookipedia.com/wiki/Spinosaurus",
"width": 2
},
{
"colors": [
"Brown"
],
"hha_base": 87,
"image_url": "https://dodo.ac/np/images/9/92/Spino_Torso_NH_Icon.png",
"interactable": true,
"length": 2,
"name": "Spino Torso",
"sell": 3000,
"url": "https://nookipedia.com/wiki/Spinosaurus",
"width": 2
}
],
"name": "Spinosaurus",
"room": 2,
"url": "https://nookipedia.com/wiki/Spinosaurus"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons fossil groups
{{baseUrl}}/nh/fossils/groups
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/fossils/groups");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/fossils/groups" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/fossils/groups"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/fossils/groups"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/fossils/groups");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/fossils/groups"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/fossils/groups HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/fossils/groups")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/fossils/groups"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/groups")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/fossils/groups")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/groups');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/fossils/groups',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/fossils/groups';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/fossils/groups',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/fossils/groups")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/fossils/groups',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/fossils/groups',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/fossils/groups');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/fossils/groups',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/fossils/groups';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/fossils/groups"]
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}}/nh/fossils/groups" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/fossils/groups",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/fossils/groups', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/fossils/groups');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/fossils/groups');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/fossils/groups' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/fossils/groups' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/fossils/groups", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/fossils/groups"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/fossils/groups"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/fossils/groups")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/fossils/groups') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/fossils/groups";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/fossils/groups \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/fossils/groups \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/fossils/groupsimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/fossils/groups")! 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
[
{
"description": "Ahem. Yes. The Spinosaurus was a very large, carnivorous dinosaur, roughly the size of a T. Rex. Unlike its more famous cousin, however, Spinosaurus seems to have spent a great deal of time in water. Similar to modern crocodiles, this creature lived on a diet of fish AND land-dwelling animals. Personally, I am simply relieved that it did not seek FLYING prey.",
"name": "Spinosaurus",
"room": 2,
"url": "https://nookipedia.com/wiki/Spinosaurus"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons fossils
{{baseUrl}}/nh/fossils/individuals
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/fossils/individuals");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/fossils/individuals" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/fossils/individuals"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/fossils/individuals"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/fossils/individuals");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/fossils/individuals"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/fossils/individuals HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/fossils/individuals")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/fossils/individuals"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/individuals")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/fossils/individuals")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/individuals');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/fossils/individuals',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/fossils/individuals';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/fossils/individuals',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/fossils/individuals")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/fossils/individuals',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/fossils/individuals',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/fossils/individuals');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/fossils/individuals',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/fossils/individuals';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/fossils/individuals"]
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}}/nh/fossils/individuals" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/fossils/individuals",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/fossils/individuals', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/fossils/individuals');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/fossils/individuals');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/fossils/individuals' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/fossils/individuals' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/fossils/individuals", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/fossils/individuals"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/fossils/individuals"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/fossils/individuals")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/fossils/individuals') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/fossils/individuals";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/fossils/individuals \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/fossils/individuals \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/fossils/individualsimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/fossils/individuals")! 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
[
{
"colors": [
"Brown"
],
"fossil_group": "Spinosaurus",
"hha_base": 87,
"image_url": "https://dodo.ac/np/images/7/7b/Spino_Skull_NH_Icon.png",
"interactable": false,
"length": 2,
"name": "Spino Skull",
"sell": 4000,
"url": "https://nookipedia.com/wiki/Spinosaurus",
"width": 2
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons furniture
{{baseUrl}}/nh/furniture
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/furniture");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/furniture" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/furniture"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/furniture"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/furniture");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/furniture"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/furniture HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/furniture")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/furniture"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/furniture")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/furniture")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/furniture');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/furniture',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/furniture';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/furniture',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/furniture")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/furniture',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/furniture',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/furniture');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/furniture',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/furniture';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/furniture"]
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}}/nh/furniture" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/furniture",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/furniture', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/furniture');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/furniture');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/furniture' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/furniture' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/furniture", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/furniture"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/furniture"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/furniture")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/furniture') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/furniture";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/furniture \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/furniture \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/furnitureimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/furniture")! 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
[
{
"availability": [
{
"from": "Nook's Cranny (Upgraded)",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 31000
}
],
"category": "Housewares",
"custom_body_part": "",
"custom_kit_type": "",
"custom_kits": 0,
"custom_pattern_part": "",
"customizable": false,
"door_decor": false,
"functions": [
"Dresser"
],
"grid_length": 1,
"grid_width": 2,
"height": 15.98677,
"hha_base": 251,
"hha_category": "Dresser",
"item_series": "Antique",
"item_set": "",
"lucky": false,
"lucky_season": "",
"name": "Antique Vanity",
"notes": "",
"pattern_total": 0,
"sell": 7750,
"tag": "Dresser",
"themes": [
"Living Room",
"Expensive"
],
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Antique_Vanity_(New_Horizons)",
"variation_total": 3,
"variations": [
{
"colors": [
"Aqua",
"Brown"
],
"image_url": "https://dodo.ac/np/images/9/9e/Antique_Vanity_%28Brown%29_NH_Icon.png",
"pattern": "",
"variation": "Brown"
},
{
"colors": [
"Aqua",
"Beige"
],
"image_url": "https://dodo.ac/np/images/a/ab/Antique_Vanity_%28Natural%29_NH_Icon.png",
"pattern": "",
"variation": "Natural"
},
{
"colors": [
"Aqua",
"Black"
],
"image_url": "https://dodo.ac/np/images/5/55/Antique_Vanity_%28Black%29_NH_Icon.png",
"pattern": "",
"variation": "Black"
}
],
"version_added": "1.0.0"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons interior items
{{baseUrl}}/nh/interior
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/interior");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/interior" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/interior"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/interior"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/interior");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/interior"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/interior HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/interior")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/interior"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/interior")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/interior")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/interior');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/interior',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/interior';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/interior',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/interior")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/interior',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/interior',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/interior');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/interior',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/interior';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/interior"]
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}}/nh/interior" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/interior",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/interior', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/interior');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/interior');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/interior' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/interior' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/interior", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/interior"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/interior"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/interior")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/interior') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/interior";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/interior \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/interior \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/interiorimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/interior")! 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
[
{
"availability": [
{
"from": "Nook's",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 1560
}
],
"category": "Wallpaper",
"colors": [
"White",
"Colorful"
],
"grid_length": 1,
"grid_width": 2,
"hha_base": 0,
"hha_category": "Dresser",
"image_url": "https://dodo.ac/np/images/2/2d/Abstract_Wall_NH_Icon.png",
"item_series": "",
"item_set": "",
"name": "Abstract Wall",
"notes": "",
"sell": 200,
"tag": "Dresser",
"themes": [
"Shop",
"Facility"
],
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Abstract_Wall_(New_Horizons)",
"version_added": "1.0.0"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons photos and posters
{{baseUrl}}/nh/photos
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/photos");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/photos" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/photos"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/photos"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/photos");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/photos"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/photos HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/photos")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/photos"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/photos")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/photos")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/photos');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/photos',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/photos';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/photos',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/photos")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/photos',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/photos',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/photos');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/photos',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/photos';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/photos"]
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}}/nh/photos" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/photos",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/photos', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/photos');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/photos');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/photos' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/photos' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/photos", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/photos"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/photos"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/photos")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/photos') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/photos";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/photos \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/photos \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/photosimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/photos")! 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
[
{
"availability": [
{
"from": "Friendship",
"note": ""
}
],
"buy": [],
"category": "Accessories",
"custom_body_part": "Frame",
"custom_kits": 1,
"customizable": false,
"grid_length": 1,
"grid_width": 2,
"interactable": true,
"name": "Admiral's Photo",
"sell": 10,
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Admiral's_Photo_(New_Horizons)",
"variations": [
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/7/72/Admiral%27s_Photo_%28Natural_Wood%29_NH_Icon.png",
"variation": "Natural Wood"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/e/e5/Admiral%27s_Photo_%28Dark_Wood%29_NH_Icon.png",
"variation": "Dark Wood"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/9/9a/Admiral%27s_Photo_%28Pastel%29_NH_Icon.png",
"variation": "Pastel"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/1/16/Admiral%27s_Photo_%28White%29_NH_Icon.png",
"variation": "White"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/b/be/Admiral%27s_Photo_%28Pop%29_NH_Icon.png",
"variation": "Pop"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/5/51/Admiral%27s_Photo_%28Colorful%29_NH_Icon.png",
"variation": "Colorful"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/e/ed/Admiral%27s_Photo_%28Silver%29_NH_Icon.png",
"variation": "Silver"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/c/cf/Admiral%27s_Photo_%28Gold%29_NH_Icon.png",
"variation": "Gold"
}
],
"version_added": "1.0.0"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons recipes
{{baseUrl}}/nh/recipes
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/recipes");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/recipes" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/recipes"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/recipes"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/recipes");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/recipes"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/recipes HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/recipes")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/recipes"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/recipes")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/recipes")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/recipes');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/recipes',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/recipes';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/recipes',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/recipes")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/recipes',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/recipes',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/recipes');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/recipes',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/recipes';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/recipes"]
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}}/nh/recipes" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/recipes",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/recipes', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/recipes');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/recipes');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/recipes' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/recipes' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/recipes", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/recipes"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/recipes"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/recipes")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/recipes') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/recipes";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/recipes \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/recipes \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/recipesimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/recipes")! 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
[
{
"availability": [
{
"from": "Tom Nook",
"note": "Obtained through Tom Nook's DIY Workshop at the beginning of the game."
},
{
"from": "Nook's Cranny",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 280
}
],
"image_url": "https://dodo.ac/np/images/a/ac/Flimsy_Axe_NH_DIY_Icon.png",
"materials": [
{
"count": 5,
"name": "Tree Branch"
},
{
"count": 1,
"name": "Stone"
}
],
"name": "Flimsy Axe",
"recipes_to_unlock": 0,
"sell": 200,
"serial_id": 100,
"url": "https://nookipedia.com/wiki/Item:Flimsy_Axe_(New_Horizons)"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons sea creatures
{{baseUrl}}/nh/sea
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/sea");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/sea" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/sea"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/sea"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/sea");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/sea"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/sea HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/sea")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/sea"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/sea")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/sea")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/sea');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/sea',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/sea';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/sea',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/sea")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/sea',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/sea',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/sea');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/sea',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/sea';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/sea"]
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}}/nh/sea" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/sea",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/sea', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/sea');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/sea');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/sea' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/sea' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/sea", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/sea"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/sea"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/sea")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/sea') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/sea";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/sea \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/sea \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/seaimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/sea")! 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
[
{
"catchphrases": [
"I got an octopus! It can give four hugs at once!"
],
"image_url": "https://dodo.ac/np/images/5/58/Octopus_NH_Icon.png",
"name": "Octopus",
"number": 20,
"rarity": "Uncommon",
"render_url": "https://dodo.ac/np/images/2/27/Octopus_NH.png",
"sell_nook": 160,
"shadow_movement": "Slow",
"shadow_size": "Medium",
"tank_length": 1,
"tank_width": 1,
"total_catch": 0,
"url": "https://nookipedia.com/wiki/Octopus_(fish)"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
All New Horizons tools
{{baseUrl}}/nh/tools
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/tools");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/tools" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/tools"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/tools"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/tools");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/tools"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/tools HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/tools")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/tools"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/tools")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/tools")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/tools');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/tools',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/tools';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/tools',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/tools")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/tools',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/tools',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/tools');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/tools',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/tools';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/tools"]
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}}/nh/tools" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/tools",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/tools', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/tools');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/tools');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/tools' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/tools' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/tools", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/tools"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/tools"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/tools")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/tools') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/tools";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/tools \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/tools \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/toolsimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/tools")! 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
[
{
"availability": [
{
"from": "Nook's Cranny",
"note": ""
},
{
"from": "Crafting",
"note": ""
}
],
"buy": [
{
"price": 2550
},
{
"currency": "Bells"
}
],
"custom_body_part": "",
"custom_kits": 0,
"customizable": false,
"hha_base": 0,
"name": "Axe",
"notes": "",
"sell": 625,
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Axe_(New_Horizons)",
"uses": 100,
"variations": [
{
"image_url": "https://dodo.ac/np/images/f/fa/Axe_NH_Icon.png",
"variation": ""
}
],
"version_added": "1.0.0"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Miscellaneous New Horizons items
{{baseUrl}}/nh/items
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/items");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/items" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/items"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/items"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/items");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/items"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/items HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/items")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/items"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/items")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/items")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/items');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/items',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/items';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/items',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/items")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/items',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/items',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/items');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/items',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/items';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/items"]
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}}/nh/items" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/items",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/items', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/items');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/items');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/items' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/items' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/items", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/items"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/items"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/items")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/items') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/items";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/items \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/items \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/itemsimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/items")! 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
[
{
"availability": [
{
"from": "Nook's",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 280
}
],
"edible": false,
"hha_base": 0,
"image_url": "https://dodo.ac/np/images/9/9f/Acorn_NH_Icon.png",
"is_fence": false,
"material_name_sort": 0,
"material_seasonality": "Autumn",
"material_seasonality_sort": 3,
"material_sort": 3,
"material_type": "Tree",
"name": "Acorn",
"notes": "",
"plant_type": "",
"sell": 200,
"stack": 30,
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Acorn_(New_Horizons)",
"version_added": "1.0.0"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons artwork
{{baseUrl}}/nh/art/:artwork
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
artwork
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/art/:artwork");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/art/:artwork" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/art/:artwork"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/art/:artwork"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/art/:artwork");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/art/:artwork"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/art/:artwork HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/art/:artwork")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/art/:artwork"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/art/:artwork")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/art/:artwork")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/art/:artwork');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/art/:artwork',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/art/:artwork';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/art/:artwork',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/art/:artwork")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/art/:artwork',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/art/:artwork',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/art/:artwork');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/art/:artwork',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/art/:artwork';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/art/:artwork"]
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}}/nh/art/:artwork" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/art/:artwork",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/art/:artwork', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/art/:artwork');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/art/:artwork');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/art/:artwork' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/art/:artwork' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/art/:artwork", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/art/:artwork"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/art/:artwork"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/art/:artwork")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/art/:artwork') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/art/:artwork";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/art/:artwork \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/art/:artwork \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/art/:artworkimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/art/:artwork")! 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
{
"art_name": "Vitruvian Man",
"art_style": "Pen and ink on paper",
"authenticity": "If there is a coffee stain in the top right corner, it is fake. If there is no stain, it is genuine. The forgery has a key taped to the back of the canvas.",
"author": "Leonardo da Vinci",
"availability": "Jolly Redd's Treasure Trawler",
"buy": 4980,
"description": "This drawing is based on the "ideal" human-body ratio, as stated in "De architectura." "De architectura" was a treatise by Vitruvius, an architect from the early 1st century BCE.",
"fake_image_url": "https://dodo.ac/np/images/1/13/Academic_Painting_%28Forgery%29_NH_Icon.png",
"has_fake": true,
"image_url": "https://dodo.ac/np/images/e/e8/Academic_Painting_NH_Icon.png",
"length": 1,
"name": "Academic Painting",
"sell": 1245,
"url": "https://nookipedia.com/wiki/Academic_Painting",
"width": 1,
"year": "circa 1487"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons bug
{{baseUrl}}/nh/bugs/:bug
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
bug
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/bugs/:bug");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/bugs/:bug" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/bugs/:bug"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/bugs/:bug"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/bugs/:bug");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/bugs/:bug"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/bugs/:bug HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/bugs/:bug")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/bugs/:bug"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/bugs/:bug")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/bugs/:bug")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/bugs/:bug');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/bugs/:bug',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/bugs/:bug';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/bugs/:bug',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/bugs/:bug")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/bugs/:bug',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/bugs/:bug',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/bugs/:bug');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/bugs/:bug',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/bugs/:bug';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/bugs/:bug"]
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}}/nh/bugs/:bug" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/bugs/:bug",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/bugs/:bug', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/bugs/:bug');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/bugs/:bug');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/bugs/:bug' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/bugs/:bug' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/bugs/:bug", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/bugs/:bug"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/bugs/:bug"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/bugs/:bug")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/bugs/:bug') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/bugs/:bug";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/bugs/:bug \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/bugs/:bug \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/bugs/:bugimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/bugs/:bug")! 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
{
"catchphrases": [
"I caught a grasshopper! They're a grass act!"
],
"image_url": "https://dodo.ac/np/images/3/37/Grasshopper_NH_Icon.png",
"location": "On the ground",
"name": "Grasshopper",
"north": {
"availability_array": [
{
"months": "Jul – Sep",
"time": "8 AM – 5 PM"
}
],
"months": "Jul – Sep",
"months_array": [
7,
8,
9
],
"times_by_month": {
"1": "NA",
"2": "NA",
"3": "NA",
"4": "NA",
"5": "NA",
"6": "NA",
"7": "8 AM – 5 PM",
"8": "8 AM – 5 PM",
"9": "8 AM – 5 PM",
"10": "NA",
"11": "NA",
"12": "NA"
}
},
"number": 19,
"rarity": "Uncommon",
"render_url": "https://dodo.ac/np/images/1/1d/Grasshopper_NH.png",
"sell_flick": 240,
"sell_nook": 160,
"south": {
"availability_array": [
{
"months": "Jan – Mar",
"time": "8 AM – 5 PM"
}
],
"months": "Jan – Mar",
"months_array": [
1,
2,
3
],
"times_by_month": {
"1": "8 AM – 5 PM",
"2": "8 AM – 5 PM",
"3": "8 AM – 5 PM",
"4": "NA",
"5": "NA",
"6": "NA",
"7": "NA",
"8": "NA",
"9": "NA",
"10": "NA",
"11": "NA",
"12": "NA"
}
},
"tank_length": 1,
"tank_width": 1,
"total_catch": 0,
"url": "https://nookipedia.com/wiki/Grasshopper"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "MediaWiki Cargo request succeeded by nothing was returned for the parameters: {}",
"title": "No data was found for the given query."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons clothing
{{baseUrl}}/nh/clothing/:clothing
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
clothing
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/clothing/:clothing");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/clothing/:clothing" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/clothing/:clothing"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/clothing/:clothing"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/clothing/:clothing");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/clothing/:clothing"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/clothing/:clothing HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/clothing/:clothing")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/clothing/:clothing"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/clothing/:clothing")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/clothing/:clothing")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/clothing/:clothing');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/clothing/:clothing',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/clothing/:clothing';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/clothing/:clothing',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/clothing/:clothing")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/clothing/:clothing',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/clothing/:clothing',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/clothing/:clothing');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/clothing/:clothing',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/clothing/:clothing';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/clothing/:clothing"]
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}}/nh/clothing/:clothing" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/clothing/:clothing",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/clothing/:clothing', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/clothing/:clothing');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/clothing/:clothing');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/clothing/:clothing' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/clothing/:clothing' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/clothing/:clothing", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/clothing/:clothing"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/clothing/:clothing"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/clothing/:clothing")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/clothing/:clothing') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/clothing/:clothing";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/clothing/:clothing \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/clothing/:clothing \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/clothing/:clothingimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/clothing/:clothing")! 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
{
"availability": [
{
"from": "Able Sisters",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 490
}
],
"category": "Accessories",
"label_themes": [
"Party"
],
"name": "3D Glasses",
"notes": "",
"seasonality": "All year",
"sell": 122,
"styles": [
"Active"
],
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:3D_Glasses_(New_Horizons)",
"variation_total": 2,
"variations": [
{
"colors": [
"White",
"Colorful"
],
"image_url": "https://dodo.ac/np/images/1/15/3D_Glasses_%28White%29_NH_Icon.png",
"variation": "White"
},
{
"colors": [
"Colorful",
"Black"
],
"image_url": "https://dodo.ac/np/images/2/28/3D_Glasses_%28Black%29_NH_Icon.png",
"variation": "Black"
}
],
"version_added": "1.0.0",
"vill_equip": true
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons fish
{{baseUrl}}/nh/fish/:fish
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
fish
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/fish/:fish");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/fish/:fish" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/fish/:fish"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/fish/:fish"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/fish/:fish");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/fish/:fish"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/fish/:fish HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/fish/:fish")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/fish/:fish"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fish/:fish")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/fish/:fish")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fish/:fish');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/fish/:fish',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/fish/:fish';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/fish/:fish',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/fish/:fish")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/fish/:fish',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/fish/:fish',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/fish/:fish');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/fish/:fish',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/fish/:fish';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/fish/:fish"]
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}}/nh/fish/:fish" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/fish/:fish",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/fish/:fish', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/fish/:fish');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/fish/:fish');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/fish/:fish' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/fish/:fish' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/fish/:fish", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/fish/:fish"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/fish/:fish"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/fish/:fish")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/fish/:fish') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/fish/:fish";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/fish/:fish \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/fish/:fish \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/fish/:fishimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/fish/:fish")! 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
{
"catchphrases": [
"I caught a cherry salmon! It's the perfect topper for a marlin sundae!"
],
"image_url": "https://dodo.ac/np/images/d/db/Cherry_Salmon_NH_Icon.png",
"location": "River (clifftop)",
"name": "Cherry Salmon",
"north": {
"availability_array": [
{
"months": "Mar – Jun",
"time": "4 PM – 9 AM"
},
{
"months": "Sep – Nov",
"time": "All day"
}
],
"months": "Mar – Jun; Sep – Nov",
"months_array": [
3,
4,
5,
6,
9,
10,
11
],
"times_by_month": {
"1": "NA",
"2": "NA",
"3": "4 PM – 9 AM",
"4": "4 PM – 9 AM",
"5": "4 PM – 9 AM",
"6": "4 PM – 9 AM",
"7": "NA",
"8": "NA",
"9": "All day",
"10": "All day",
"11": "All day",
"12": "NA"
}
},
"number": 27,
"rarity": "Uncommon",
"render_url": "https://dodo.ac/np/images/c/c0/Cherry_Salmon_NH.png",
"sell_cj": 1500,
"sell_nook": 1000,
"shadow_size": "Small",
"south": {
"availability_array": [
{
"months": "Sep – Dec",
"time": "4 PM – 9 AM"
},
{
"months": "Mar – May",
"time": "All day"
}
],
"months": "Mar – May; Sep – Dec",
"months_array": [
3,
4,
5,
9,
10,
11,
12
],
"times_by_month": {
"1": "NA",
"2": "NA",
"3": "4 PM – 9 AM",
"4": "4 PM – 9 AM",
"5": "4 PM – 9 AM",
"6": "4 PM – 9 AM",
"7": "NA",
"8": "NA",
"9": "All day",
"10": "All day",
"11": "All day",
"12": "NA"
}
},
"tank_length": 1,
"tank_width": 1,
"total_catch": 100,
"url": "https://nookipedia.com/wiki/Cherry Salmon"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "MediaWiki Cargo request succeeded by nothing was returned for the parameters: {}",
"title": "No data was found for the given query."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons fossil group with individual fossils
{{baseUrl}}/nh/fossils/all/:fossil
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
fossil
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/fossils/all/:fossil");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/fossils/all/:fossil" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/fossils/all/:fossil"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/fossils/all/:fossil"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/fossils/all/:fossil");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/fossils/all/:fossil"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/fossils/all/:fossil HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/fossils/all/:fossil")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/fossils/all/:fossil"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/all/:fossil")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/fossils/all/:fossil")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/all/:fossil');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/fossils/all/:fossil',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/fossils/all/:fossil';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/fossils/all/:fossil',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/fossils/all/:fossil")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/fossils/all/:fossil',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/fossils/all/:fossil',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/fossils/all/:fossil');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/fossils/all/:fossil',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/fossils/all/:fossil';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/fossils/all/:fossil"]
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}}/nh/fossils/all/:fossil" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/fossils/all/:fossil",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/fossils/all/:fossil', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/fossils/all/:fossil');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/fossils/all/:fossil');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/fossils/all/:fossil' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/fossils/all/:fossil' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/fossils/all/:fossil", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/fossils/all/:fossil"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/fossils/all/:fossil"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/fossils/all/:fossil")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/fossils/all/:fossil') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/fossils/all/:fossil";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/fossils/all/:fossil \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/fossils/all/:fossil \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/fossils/all/:fossilimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/fossils/all/:fossil")! 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
{
"description": "Ahem. Yes. The Spinosaurus was a very large, carnivorous dinosaur, roughly the size of a T. Rex. Unlike its more famous cousin, however, Spinosaurus seems to have spent a great deal of time in water. Similar to modern crocodiles, this creature lived on a diet of fish AND land-dwelling animals. Personally, I am simply relieved that it did not seek FLYING prey.",
"fossils": [
{
"colors": [
"Brown"
],
"hha_base": 87,
"image_url": "https://dodo.ac/np/images/7/7b/Spino_Skull_NH_Icon.png",
"interactable": true,
"length": 2,
"name": "Spino Skull",
"sell": 4000,
"url": "https://nookipedia.com/wiki/Spinosaurus",
"width": 2
},
{
"colors": [
"Brown"
],
"hha_base": 87,
"image_url": "https://dodo.ac/np/images/4/40/Spino_Tail_NH_Icon.png",
"interactable": true,
"length": 2,
"name": "Spino Tail",
"sell": 2500,
"url": "https://nookipedia.com/wiki/Spinosaurus",
"width": 2
},
{
"colors": [
"Brown"
],
"hha_base": 87,
"image_url": "https://dodo.ac/np/images/9/92/Spino_Torso_NH_Icon.png",
"interactable": true,
"length": 2,
"name": "Spino Torso",
"sell": 3000,
"url": "https://nookipedia.com/wiki/Spinosaurus",
"width": 2
}
],
"matched": {
"name": "Spino Skull",
"type": "individual"
},
"name": "Spinosaurus",
"room": 2,
"url": "https://nookipedia.com/wiki/Spinosaurus"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons fossil group
{{baseUrl}}/nh/fossils/groups/:fossil_group
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
fossil_group
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/fossils/groups/:fossil_group");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/fossils/groups/:fossil_group" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/fossils/groups/:fossil_group"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/fossils/groups/:fossil_group"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/fossils/groups/:fossil_group");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/fossils/groups/:fossil_group"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/fossils/groups/:fossil_group HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/fossils/groups/:fossil_group")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/fossils/groups/:fossil_group"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/groups/:fossil_group")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/fossils/groups/:fossil_group")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/groups/:fossil_group');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/fossils/groups/:fossil_group',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/fossils/groups/:fossil_group';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/fossils/groups/:fossil_group',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/fossils/groups/:fossil_group")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/fossils/groups/:fossil_group',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/fossils/groups/:fossil_group',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/fossils/groups/:fossil_group');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/fossils/groups/:fossil_group',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/fossils/groups/:fossil_group';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/fossils/groups/:fossil_group"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume]; open Cohttp_lwt_unix
open Cohttp
open Lwt
let uri = Uri.of_string "{{baseUrl}}/nh/fossils/groups/:fossil_group" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/fossils/groups/:fossil_group",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/fossils/groups/:fossil_group', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/fossils/groups/:fossil_group');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/fossils/groups/:fossil_group');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/fossils/groups/:fossil_group' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/fossils/groups/:fossil_group' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/fossils/groups/:fossil_group", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/fossils/groups/:fossil_group"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/fossils/groups/:fossil_group"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/fossils/groups/:fossil_group")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/fossils/groups/:fossil_group') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/fossils/groups/:fossil_group";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/fossils/groups/:fossil_group \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/fossils/groups/:fossil_group \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/fossils/groups/:fossil_groupimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/fossils/groups/:fossil_group")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error as Any)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"description": "Ahem. Yes. The Spinosaurus was a very large, carnivorous dinosaur, roughly the size of a T. Rex. Unlike its more famous cousin, however, Spinosaurus seems to have spent a great deal of time in water. Similar to modern crocodiles, this creature lived on a diet of fish AND land-dwelling animals. Personally, I am simply relieved that it did not seek FLYING prey.",
"name": "Spinosaurus",
"room": 2,
"url": "https://nookipedia.com/wiki/Spinosaurus"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons fossil
{{baseUrl}}/nh/fossils/individuals/:fossil
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
fossil
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/fossils/individuals/:fossil");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/fossils/individuals/:fossil" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/fossils/individuals/:fossil"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/fossils/individuals/:fossil"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/fossils/individuals/:fossil");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/fossils/individuals/:fossil"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/fossils/individuals/:fossil HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/fossils/individuals/:fossil")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/fossils/individuals/:fossil"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/individuals/:fossil")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/fossils/individuals/:fossil")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/fossils/individuals/:fossil');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/fossils/individuals/:fossil',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/fossils/individuals/:fossil';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/fossils/individuals/:fossil',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/fossils/individuals/:fossil")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/fossils/individuals/:fossil',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/fossils/individuals/:fossil',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/fossils/individuals/:fossil');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/fossils/individuals/:fossil',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/fossils/individuals/:fossil';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/fossils/individuals/:fossil"]
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}}/nh/fossils/individuals/:fossil" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/fossils/individuals/:fossil",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/fossils/individuals/:fossil', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/fossils/individuals/:fossil');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/fossils/individuals/:fossil');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/fossils/individuals/:fossil' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/fossils/individuals/:fossil' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/fossils/individuals/:fossil", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/fossils/individuals/:fossil"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/fossils/individuals/:fossil"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/fossils/individuals/:fossil")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/fossils/individuals/:fossil') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/fossils/individuals/:fossil";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/fossils/individuals/:fossil \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/fossils/individuals/:fossil \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/fossils/individuals/:fossilimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/fossils/individuals/:fossil")! 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
{
"colors": [
"Brown"
],
"fossil_group": "Spinosaurus",
"hha_base": 87,
"image_url": "https://dodo.ac/np/images/7/7b/Spino_Skull_NH_Icon.png",
"interactable": false,
"length": 2,
"name": "Spino Skull",
"sell": 4000,
"url": "https://nookipedia.com/wiki/Spinosaurus",
"width": 2
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons furniture
{{baseUrl}}/nh/furniture/:furniture
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
furniture
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/furniture/:furniture");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/furniture/:furniture" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/furniture/:furniture"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/furniture/:furniture"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/furniture/:furniture");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/furniture/:furniture"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/furniture/:furniture HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/furniture/:furniture")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/furniture/:furniture"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/furniture/:furniture")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/furniture/:furniture")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/furniture/:furniture');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/furniture/:furniture',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/furniture/:furniture';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/furniture/:furniture',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/furniture/:furniture")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/furniture/:furniture',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/furniture/:furniture',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/furniture/:furniture');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/furniture/:furniture',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/furniture/:furniture';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/furniture/:furniture"]
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}}/nh/furniture/:furniture" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/furniture/:furniture",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/furniture/:furniture', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/furniture/:furniture');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/furniture/:furniture');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/furniture/:furniture' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/furniture/:furniture' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/furniture/:furniture", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/furniture/:furniture"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/furniture/:furniture"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/furniture/:furniture")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/furniture/:furniture') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/furniture/:furniture";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/furniture/:furniture \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/furniture/:furniture \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/furniture/:furnitureimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/furniture/:furniture")! 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
{
"availability": [
{
"from": "Nook's Cranny (Upgraded)",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 31000
}
],
"category": "Housewares",
"custom_body_part": "",
"custom_kit_type": "",
"custom_kits": 0,
"custom_pattern_part": "",
"customizable": false,
"door_decor": false,
"functions": [
"Dresser"
],
"grid_length": 1,
"grid_width": 2,
"height": 15.98677,
"hha_base": 251,
"hha_category": "Dresser",
"item_series": "Antique",
"item_set": "",
"lucky": false,
"lucky_season": "",
"name": "Antique Vanity",
"notes": "",
"pattern_total": 0,
"sell": 7750,
"tag": "Dresser",
"themes": [
"Living Room",
"Expensive"
],
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Antique_Vanity_(New_Horizons)",
"variation_total": 3,
"variations": [
{
"colors": [
"Aqua",
"Brown"
],
"image_url": "https://dodo.ac/np/images/9/9e/Antique_Vanity_%28Brown%29_NH_Icon.png",
"pattern": "",
"variation": "Brown"
},
{
"colors": [
"Aqua",
"Beige"
],
"image_url": "https://dodo.ac/np/images/a/ab/Antique_Vanity_%28Natural%29_NH_Icon.png",
"pattern": "",
"variation": "Natural"
},
{
"colors": [
"Aqua",
"Black"
],
"image_url": "https://dodo.ac/np/images/5/55/Antique_Vanity_%28Black%29_NH_Icon.png",
"pattern": "",
"variation": "Black"
}
],
"version_added": "1.0.0"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons interior item
{{baseUrl}}/nh/interior/:item
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
item
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/interior/:item");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/interior/:item" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/interior/:item"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/interior/:item"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/interior/:item");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/interior/:item"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/interior/:item HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/interior/:item")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/interior/:item"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/interior/:item")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/interior/:item")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/interior/:item');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/interior/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/interior/:item';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/interior/:item',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/interior/:item")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/interior/:item',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/interior/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/interior/:item');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/interior/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/interior/:item';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/interior/:item"]
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}}/nh/interior/:item" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/interior/:item",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/interior/:item', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/interior/:item');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/interior/:item');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/interior/:item' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/interior/:item' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/interior/:item", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/interior/:item"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/interior/:item"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/interior/:item")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/interior/:item') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/interior/:item";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/interior/:item \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/interior/:item \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/interior/:itemimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/interior/:item")! 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
{
"availability": [
{
"from": "Nook's",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 1560
}
],
"category": "Wallpaper",
"colors": [
"White",
"Colorful"
],
"grid_length": 1,
"grid_width": 2,
"hha_base": 0,
"hha_category": "Dresser",
"image_url": "https://dodo.ac/np/images/2/2d/Abstract_Wall_NH_Icon.png",
"item_series": "",
"item_set": "",
"name": "Abstract Wall",
"notes": "",
"sell": 200,
"tag": "Dresser",
"themes": [
"Shop",
"Facility"
],
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Abstract_Wall_(New_Horizons)",
"version_added": "1.0.0"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons miscellaneous item
{{baseUrl}}/nh/items/:item
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
item
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/items/:item");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/items/:item" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/items/:item"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/items/:item"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/items/:item");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/items/:item"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/items/:item HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/items/:item")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/items/:item"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/items/:item")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/items/:item")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/items/:item');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/items/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/items/:item';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/items/:item',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/items/:item")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/items/:item',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/items/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/items/:item');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/items/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/items/:item';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/items/:item"]
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}}/nh/items/:item" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/items/:item",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/items/:item', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/items/:item');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/items/:item');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/items/:item' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/items/:item' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/items/:item", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/items/:item"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/items/:item"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/items/:item")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/items/:item') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/items/:item";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/items/:item \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/items/:item \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/items/:itemimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/items/:item")! 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
{
"availability": [
{
"from": "Nook's",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 280
}
],
"edible": false,
"hha_base": 0,
"image_url": "https://dodo.ac/np/images/9/9f/Acorn_NH_Icon.png",
"is_fence": false,
"material_name_sort": 0,
"material_seasonality": "Autumn",
"material_seasonality_sort": 3,
"material_sort": 3,
"material_type": "Tree",
"name": "Acorn",
"notes": "",
"plant_type": "",
"sell": 200,
"stack": 30,
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Acorn_(New_Horizons)",
"version_added": "1.0.0"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons photo or poster
{{baseUrl}}/nh/photos/:item
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
item
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/photos/:item");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/photos/:item" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/photos/:item"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/photos/:item"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/photos/:item");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/photos/:item"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/photos/:item HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/photos/:item")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/photos/:item"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/photos/:item")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/photos/:item")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/photos/:item');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/photos/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/photos/:item';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/photos/:item',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/photos/:item")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/photos/:item',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/photos/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/photos/:item');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/photos/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/photos/:item';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/photos/:item"]
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}}/nh/photos/:item" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/photos/:item",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/photos/:item', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/photos/:item');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/photos/:item');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/photos/:item' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/photos/:item' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/photos/:item", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/photos/:item"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/photos/:item"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/photos/:item")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/photos/:item') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/photos/:item";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/photos/:item \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/photos/:item \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/photos/:itemimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/photos/:item")! 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
{
"availability": [
{
"from": "Friendship",
"note": ""
}
],
"buy": [],
"category": "Accessories",
"custom_body_part": "Frame",
"custom_kits": 1,
"customizable": false,
"grid_length": 1,
"grid_width": 2,
"interactable": true,
"name": "Admiral's Photo",
"sell": 10,
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Admiral's_Photo_(New_Horizons)",
"variations": [
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/7/72/Admiral%27s_Photo_%28Natural_Wood%29_NH_Icon.png",
"variation": "Natural Wood"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/e/e5/Admiral%27s_Photo_%28Dark_Wood%29_NH_Icon.png",
"variation": "Dark Wood"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/9/9a/Admiral%27s_Photo_%28Pastel%29_NH_Icon.png",
"variation": "Pastel"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/1/16/Admiral%27s_Photo_%28White%29_NH_Icon.png",
"variation": "White"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/b/be/Admiral%27s_Photo_%28Pop%29_NH_Icon.png",
"variation": "Pop"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/5/51/Admiral%27s_Photo_%28Colorful%29_NH_Icon.png",
"variation": "Colorful"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/e/ed/Admiral%27s_Photo_%28Silver%29_NH_Icon.png",
"variation": "Silver"
},
{
"colors": [
"Blue",
"Green"
],
"image_url": "https://dodo.ac/np/images/c/cf/Admiral%27s_Photo_%28Gold%29_NH_Icon.png",
"variation": "Gold"
}
],
"version_added": "1.0.0"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons recipe
{{baseUrl}}/nh/recipes/:item
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
item
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/recipes/:item");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/recipes/:item" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/recipes/:item"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/recipes/:item"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/recipes/:item");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/recipes/:item"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/recipes/:item HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/recipes/:item")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/recipes/:item"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/recipes/:item")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/recipes/:item")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/recipes/:item');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/recipes/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/recipes/:item';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/recipes/:item',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/recipes/:item")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/recipes/:item',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/recipes/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/recipes/:item');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/recipes/:item',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/recipes/:item';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/recipes/:item"]
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}}/nh/recipes/:item" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/recipes/:item",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/recipes/:item', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/recipes/:item');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/recipes/:item');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/recipes/:item' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/recipes/:item' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/recipes/:item", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/recipes/:item"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/recipes/:item"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/recipes/:item")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/recipes/:item') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/recipes/:item";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/recipes/:item \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/recipes/:item \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/recipes/:itemimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/recipes/:item")! 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
{
"availability": [
{
"from": "Tom Nook",
"note": "Obtained through Tom Nook's DIY Workshop at the beginning of the game."
},
{
"from": "Nook's Cranny",
"note": ""
}
],
"buy": [
{
"currency": "Bells",
"price": 280
}
],
"image_url": "https://dodo.ac/np/images/a/ac/Flimsy_Axe_NH_DIY_Icon.png",
"materials": [
{
"count": 5,
"name": "Tree Branch"
},
{
"count": 1,
"name": "Stone"
}
],
"name": "Flimsy Axe",
"recipes_to_unlock": 0,
"sell": 200,
"serial_id": 100,
"url": "https://nookipedia.com/wiki/Item:Flimsy_Axe_(New_Horizons)"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons sea creature
{{baseUrl}}/nh/sea/:sea_creature
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
sea_creature
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/sea/:sea_creature");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/sea/:sea_creature" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/sea/:sea_creature"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/sea/:sea_creature"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/sea/:sea_creature");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/sea/:sea_creature"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/sea/:sea_creature HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/sea/:sea_creature")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/sea/:sea_creature"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/sea/:sea_creature")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/sea/:sea_creature")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/sea/:sea_creature');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/sea/:sea_creature',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/sea/:sea_creature';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/sea/:sea_creature',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/sea/:sea_creature")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/sea/:sea_creature',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/sea/:sea_creature',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/sea/:sea_creature');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/sea/:sea_creature',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/sea/:sea_creature';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/sea/:sea_creature"]
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}}/nh/sea/:sea_creature" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/sea/:sea_creature",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/sea/:sea_creature', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/sea/:sea_creature');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/sea/:sea_creature');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/sea/:sea_creature' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/sea/:sea_creature' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/sea/:sea_creature", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/sea/:sea_creature"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/sea/:sea_creature"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/sea/:sea_creature")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/sea/:sea_creature') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/sea/:sea_creature";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/sea/:sea_creature \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/sea/:sea_creature \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/sea/:sea_creatureimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/sea/:sea_creature")! 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
{
"catchphrases": [
"I got an octopus! It can give four hugs at once!"
],
"image_url": "https://dodo.ac/np/images/5/58/Octopus_NH_Icon.png",
"name": "Octopus",
"north": {
"availability_array": [
{
"months": "All year",
"time": "All day"
}
],
"months": "Jul – Sep",
"months_array": [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12
],
"times_by_month": {
"1": "All day",
"2": "All day",
"3": "All day",
"4": "All day",
"5": "All day",
"6": "All day",
"7": "All day",
"8": "All day",
"9": "All day",
"10": "All day",
"11": "All day",
"12": "All day"
}
},
"number": 20,
"rarity": "Uncommon",
"render_url": "https://dodo.ac/np/images/2/27/Octopus_NH.png",
"sell_nook": 160,
"shadow_movement": "Slow",
"shadow_size": "Medium",
"south": {
"availability_array": [
{
"months": "All year",
"time": "All day"
}
],
"months": "Jan – Mar",
"months_array": [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12
],
"times_by_month": {
"1": "All day",
"2": "All day",
"3": "All day",
"4": "All day",
"5": "All day",
"6": "All day",
"7": "All day",
"8": "All day",
"9": "All day",
"10": "All day",
"11": "All day",
"12": "All day"
}
},
"tank_length": 1,
"tank_width": 1,
"total_catch": 0,
"url": "https://nookipedia.com/wiki/Octopus_(fish)"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "MediaWiki Cargo request succeeded by nothing was returned for the parameters: {}",
"title": "No data was found for the given query."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Single New Horizons tool
{{baseUrl}}/nh/tools/:tool
HEADERS
X-API-KEY
Accept-Version
QUERY PARAMS
tool
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/nh/tools/:tool");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/nh/tools/:tool" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/nh/tools/:tool"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/nh/tools/:tool"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/nh/tools/:tool");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/nh/tools/:tool"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/nh/tools/:tool HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/nh/tools/:tool")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/nh/tools/:tool"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/tools/:tool")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/nh/tools/:tool")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/nh/tools/:tool');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/nh/tools/:tool',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/nh/tools/:tool';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/nh/tools/:tool',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/nh/tools/:tool")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/nh/tools/:tool',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/nh/tools/:tool',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/nh/tools/:tool');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/nh/tools/:tool',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/nh/tools/:tool';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/nh/tools/:tool"]
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}}/nh/tools/:tool" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/nh/tools/:tool",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/nh/tools/:tool', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/nh/tools/:tool');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/nh/tools/:tool');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/nh/tools/:tool' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/nh/tools/:tool' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/nh/tools/:tool", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/nh/tools/:tool"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/nh/tools/:tool"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/nh/tools/:tool")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/nh/tools/:tool') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/nh/tools/:tool";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/nh/tools/:tool \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/nh/tools/:tool \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/nh/tools/:toolimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/nh/tools/:tool")! 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
{
"availability": [
{
"from": "Nook's Cranny",
"note": ""
},
{
"from": "Crafting",
"note": ""
}
],
"buy": [
{
"price": 2550
},
{
"currency": "Bells"
}
],
"custom_body_part": "",
"custom_kits": 0,
"customizable": false,
"hha_base": 0,
"name": "Axe",
"notes": "",
"sell": 625,
"unlocked": true,
"url": "https://nookipedia.com/wiki/Item:Axe_(New_Horizons)",
"uses": 100,
"variations": [
{
"image_url": "https://dodo.ac/np/images/f/fa/Axe_NH_Icon.png",
"variation": ""
}
],
"version_added": "1.0.0"
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}
GET
Villagers
{{baseUrl}}/villagers
HEADERS
X-API-KEY
Accept-Version
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/villagers");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-api-key: ");
headers = curl_slist_append(headers, "accept-version: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/get "{{baseUrl}}/villagers" {:headers {:x-api-key ""
:accept-version ""}})require "http/client"
url = "{{baseUrl}}/villagers"
headers = HTTP::Headers{
"x-api-key" => ""
"accept-version" => ""
}
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}}/villagers"),
Headers =
{
{ "x-api-key", "" },
{ "accept-version", "" },
},
};
using (var response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);
}var client = new RestClient("{{baseUrl}}/villagers");
var request = new RestRequest("", Method.Get);
request.AddHeader("x-api-key", "");
request.AddHeader("accept-version", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/villagers"
req, _ := http.NewRequest("GET", url, nil)
req.Header.Add("x-api-key", "")
req.Header.Add("accept-version", "")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := io.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}GET /baseUrl/villagers HTTP/1.1
X-Api-Key:
Accept-Version:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/villagers")
.setHeader("x-api-key", "")
.setHeader("accept-version", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/villagers"))
.header("x-api-key", "")
.header("accept-version", "")
.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}}/villagers")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.get("{{baseUrl}}/villagers")
.header("x-api-key", "")
.header("accept-version", "")
.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}}/villagers');
xhr.setRequestHeader('x-api-key', '');
xhr.setRequestHeader('accept-version', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'GET',
url: '{{baseUrl}}/villagers',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/villagers';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
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}}/villagers',
method: 'GET',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/villagers")
.get()
.addHeader("x-api-key", "")
.addHeader("accept-version", "")
.build()
val response = client.newCall(request).execute()const http = require('https');
const options = {
method: 'GET',
hostname: 'example.com',
port: null,
path: '/baseUrl/villagers',
headers: {
'x-api-key': '',
'accept-version': ''
}
};
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}}/villagers',
headers: {'x-api-key': '', 'accept-version': ''}
};
request(options, function (error, response, body) {
if (error) throw new Error(error);
console.log(body);
});const unirest = require('unirest');
const req = unirest('GET', '{{baseUrl}}/villagers');
req.headers({
'x-api-key': '',
'accept-version': ''
});
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}}/villagers',
headers: {'x-api-key': '', 'accept-version': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const fetch = require('node-fetch');
const url = '{{baseUrl}}/villagers';
const options = {method: 'GET', headers: {'x-api-key': '', 'accept-version': ''}};
try {
const response = await fetch(url, options);
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}#import
NSDictionary *headers = @{ @"x-api-key": @"",
@"accept-version": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/villagers"]
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}}/villagers" in
let headers = Header.add_list (Header.init ()) [
("x-api-key", "");
("accept-version", "");
] in
Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/villagers",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"accept-version: ",
"x-api-key: "
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}request('GET', '{{baseUrl}}/villagers', [
'headers' => [
'accept-version' => '',
'x-api-key' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/villagers');
$request->setMethod(HTTP_METH_GET);
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/villagers');
$request->setRequestMethod('GET');
$request->setHeaders([
'x-api-key' => '',
'accept-version' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/villagers' -Method GET -Headers $headers$headers=@{}
$headers.Add("x-api-key", "")
$headers.Add("accept-version", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/villagers' -Method GET -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = {
'x-api-key': "",
'accept-version': ""
}
conn.request("GET", "/baseUrl/villagers", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/villagers"
headers = {
"x-api-key": "",
"accept-version": ""
}
response = requests.get(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/villagers"
response <- VERB("GET", url, add_headers('x-api-key' = '', 'accept-version' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/villagers")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Get.new(url)
request["x-api-key"] = ''
request["accept-version"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.get('/baseUrl/villagers') do |req|
req.headers['x-api-key'] = ''
req.headers['accept-version'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/villagers";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-api-key", "".parse().unwrap());
headers.insert("accept-version", "".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}}/villagers \
--header 'accept-version: ' \
--header 'x-api-key: 'http GET {{baseUrl}}/villagers \
accept-version:'' \
x-api-key:''wget --quiet \
--method GET \
--header 'x-api-key: ' \
--header 'accept-version: ' \
--output-document \
- {{baseUrl}}/villagersimport Foundation
let headers = [
"x-api-key": "",
"accept-version": ""
]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/villagers")! 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
[
{
"alt_name": "",
"appearances": [
"DNM",
"AC",
"E_PLUS",
"WW",
"CF",
"NL",
"WA",
"NH",
"HHD",
"PC"
],
"birthday_day": "13",
"birthday_month": "February",
"clothing": "Simple Parka",
"debut": "DNM",
"gender": "Male",
"id": "flg01",
"image_url": "https://dodo.ac/np/images/9/94/Ribbot_NH.png",
"islander": false,
"name": "Ribbot",
"personality": "Jock",
"phrase": "zzrrbbit",
"prev_phrases": [
"toady"
],
"quote": "Never rest, never rust.",
"sign": "Aquarius",
"species": "Frog",
"text_color": "5e5e5e",
"title_color": "bfbfbf",
"url": "https://nookipedia.com/wiki/Ribbot"
}
]RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Provided month filter jonuary was not recognized as a valid month.",
"title": "Failed to identify the provided month filter."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "UUID is either missing or invalid; or, unspecified server occured.",
"title": "Failed to validate UUID."
}RESPONSE HEADERS
Content-Type
application/json
RESPONSE BODY json
{
"details": "Details unknown.",
"title": "API experienced a fatal error."
}