API Root

GET / HTTP/1.1
Host: api.my-store.com/
Authorization: Basic ZGVtbzpwQDU1dzByZA==

curl -iX GET https://api.my-store.com// \
-H 'Authorization: Basic ZGVtbzpwQDU1dzByZA==' \

$headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$headers.Add("Host", "api.my-store.com/")
$headers.Add("Authorization", "Basic ZGVtbzpwQDU1dzByZA==")

$response = Invoke-RestMethod 'https://api.my-store.com//' -Method 'GET' -Headers $headers -Body $body
$response | ConvertTo-Json

var myHeaders = new Headers();
myHeaders.append("Host", "api.my-store.com/");
myHeaders.append("Authorization", "Basic ZGVtbzpwQDU1dzByZA==");

var requestOptions = {
  method: 'GET',
  headers: myHeaders,
  redirect: 'follow'
};

fetch("https://api.my-store.com//", requestOptions)
  .then(response => response.text())
  .then(result => console.log(result))
  .catch(error => console.log('error', error));

var request = require('request');
var options = {
  'method': 'GET',
  'url': 'https://api.my-store.com//',
  'headers': {
    'Host': 'api.my-store.com/',
    'Authorization': 'Basic ZGVtbzpwQDU1dzByZA=='
  }
};
request(options, function (error, response) { 
  if (error) throw new Error(error);
  console.log(response.body);
});

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
  CURLOPT_URL => "https://api.my-store.com//",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 0,
  CURLOPT_FOLLOWLOCATION => true,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => array(
    "Host: api.my-store.com/",
    "Authorization: Basic ZGVtbzpwQDU1dzByZA=="
  ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;

import requests

url = "https://api.my-store.com//"

payload = {}
headers = {
  'Host': 'api.my-store.com/',
  'Authorization': 'Basic ZGVtbzpwQDU1dzByZA=='
}

response = requests.request("GET", url, headers=headers, data = payload)

print(response.text.encode('utf8'))

require "uri"
require "net/http"

url = URI("https://api.my-store.com//")

https = Net::HTTP.new(url.host, url.port);
https.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Host"] = "api.my-store.com/"
request["Authorization"] = "Basic ZGVtbzpwQDU1dzByZA=="

response = https.request(request)
puts response.read_body

var client = new RestClient("https://api.my-store.com//");
client.Timeout = -1;
var request = new RestRequest(Method.GET);
request.AddHeader("Host", "api.my-store.com/");
request.AddHeader("Authorization", "Basic ZGVtbzpwQDU1dzByZA==");
IRestResponse response = client.Execute(request);
Console.WriteLine(response.Content);

OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
Request request = new Request.Builder()
  .url("https://api.my-store.com//")
  .method("GET", null)
  .addHeader("Host", "api.my-store.com/")
  .addHeader("Authorization", "Basic ZGVtbzpwQDU1dzByZA==")
  .build();
Response response = client.newCall(request).execute();

package main

import (
  "fmt"
  "net/http"
  "io/ioutil"
)

func main() {

  url := "https://api.my-store.com//"
  method := "GET"

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, nil)

  if err != nil {
    fmt.Println(err)
  }
  req.Header.Add("Host", "api.my-store.com/")
  req.Header.Add("Authorization", "Basic ZGVtbzpwQDU1dzByZA==")

  res, err := client.Do(req)
  defer res.Body.Close()
  body, err := ioutil.ReadAll(res.Body)

  fmt.Println(string(body))
}

#import <Foundation/Foundation.h>

dispatch_semaphore_t sema = dispatch_semaphore_create(0);

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://api.my-store.com//"]
  cachePolicy:NSURLRequestUseProtocolCachePolicy
  timeoutInterval:10.0];
NSDictionary *headers = @{
  @"Host": @"api.my-store.com/",
  @"Authorization": @"Basic ZGVtbzpwQDU1dzByZA=="
};

[request setAllHTTPHeaderFields:headers];

[request setHTTPMethod:@"GET"];

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;
    NSError *parseError = nil;
    NSDictionary *responseDictionary = [NSJSONSerialization JSONObjectWithData:data options:0 error:&parseError];
    NSLog(@"%@",responseDictionary);
    dispatch_semaphore_signal(sema);
  }
}];
[dataTask resume];
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);

import Foundation

var semaphore = DispatchSemaphore (value: 0)

var request = URLRequest(url: URL(string: "https://api.my-store.com//")!,timeoutInterval: Double.infinity)
request.addValue("api.my-store.com/", forHTTPHeaderField: "Host")
request.addValue("Basic ZGVtbzpwQDU1dzByZA==", forHTTPHeaderField: "Authorization")

request.httpMethod = "GET"

let task = URLSession.shared.dataTask(with: request) { data, response, error in 
  guard let data = data else {
    print(String(describing: error))
    return
  }
  print(String(data: data, encoding: .utf8)!)
  semaphore.signal()
}

task.resume()
semaphore.wait()

{
  "spec_version": "1.0.0",
  "links": {
    "self": {
      "href": "https://api.my-store.com",
      "allow": ["GET"]
    },
    "orders": {
      "href": "https://api.my-store.com/orders",
      "allow": ["GET"]
    },
    "events": {
      "href": "https://api.my-store.com/events",
      "allow": ["POST"]
    }
  }
}