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.body
using 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 $headers
import 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_body
require '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.body
use 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/art
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/bugs
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/clothing
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/events
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/fish
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/all
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/groups
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/individuals
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/furniture
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/interior
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/photos
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/recipes
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/sea
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/tools
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/items
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:artwork
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:bug
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:clothing
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:fish
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:fossil
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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_group
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:fossil
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:furniture
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:item
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:item
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:item
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:item
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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_creature
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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/:tool
import 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.body
using 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 $headers
import 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_body
require '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.body
use 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}}/villagers
import 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."
}