Error Handling

{
  "errors": [
    {
      "id":"12345678-abcd-0000-0000-000000000000",
      "code": "XXX",
      "message": "description of first error"
    },
    {
      "id":"23456789-abcd-0000-0000-000000000000",
      "code": "YYY",
      "message": "description of second error"
    }
  ]
}

curl --request GET \
     --url https://api.us.ascenda.com/api/users/id \
     --header 'accept: application/json' \
     --header 'Authorization: Bearer ee6xxxxxxxxxxxxxxx598' \
     --header 'X-Request-ID: 12345678-0000-0000-0000-000000000000'

fetch('https://api.us.ascenda.com/api/users/id', {
  method: 'GET',
  headers: {
    'Accept': 'application/json',
    'Authorization': 'Bearer ee6xxxxxxxxxxxxxxx598',
    'X-Request-ID': '12345678-0000-0000-0000-000000000000'
  }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

import requests

url = "https://api.us.ascenda.com/api/users/id"
headers = {
    'accept': 'application/json',
    'Authorization': 'Bearer ee6xxxxxxxxxxxxxxx598',
    'X-Request-ID': '12345678-0000-0000-0000-000000000000'
}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    data = response.json()
    print(data)
else:
    print(f"Request failed with status code: {response.status_code}")

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class ApiRequest {
    public static void main(String[] args) {
        try {
            String url = "https://api.us.ascenda.com/api/users/id";
            URL obj = new URL(url);
            HttpURLConnection con = (HttpURLConnection) obj.openConnection();

            // Setting request method to GET
            con.setRequestMethod("GET");

            // Adding request headers
            con.setRequestProperty("Accept", "application/json");
            con.setRequestProperty("Authorization", "Bearer ee6xxxxxxxxxxxxxxx598");
            con.setRequestProperty("X-Request-ID", "12345678-0000-0000-0000-000000000000");

            int responseCode = con.getResponseCode();
            System.out.println("Response Code : " + responseCode);

            if (responseCode == HttpURLConnection.HTTP_OK) { // success
                BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
                String inputLine;
                StringBuffer response = new StringBuffer();

                while ((inputLine = in.readLine()) != null) {
                    response.append(inputLine);
                }
                in.close();

                // Print result
                System.out.println(response.toString());
            } else {
                System.out.println("GET request not worked");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var client = new HttpClient();
        var request = new HttpRequestMessage(HttpMethod.Get, "https://api.us.ascenda.com/api/users/id");

        request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "ee6xxxxxxxxxxxxxxx598");
        request.Headers.Add("X-Request-ID", "12345678-0000-0000-0000-000000000000");

        HttpResponseMessage response = await client.SendAsync(request);

        if (response.IsSuccessStatusCode)
        {
            string responseBody = await response.Content.ReadAsStringAsync();
            Console.WriteLine(responseBody);
        }
        else
        {
            Console.WriteLine($"Request failed with status code: {response.StatusCode}");
        }
    }
}

<?php
$url = "https://api.us.ascenda.com/api/users/id";

$ch = curl_init($url);

// Set request method to GET
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");

// Set headers
$headers = [
    'Accept: application/json',
    'Authorization: Bearer ee6xxxxxxxxxxxxxxx598',
    'X-Request-ID: 12345678-0000-0000-0000-000000000000'
];
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

// Return response instead of outputting
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);

if ($response === false) {
    echo 'Curl error: ' . curl_error($ch);
} else {
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    if ($httpCode == 200) {
        echo 'Response: ' . $response;
    } else {
        echo 'Request failed with status code: ' . $httpCode;
    }
}

curl_close($ch);
?>

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.us.ascenda.com/api/users/id')

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri.request_uri)
request['Accept'] = 'application/json'
request['Authorization'] = 'Bearer ee6xxxxxxxxxxxxxxx598'
request['X-Request-ID'] = '12345678-0000-0000-0000-000000000000'

response = http.request(request)

if response.code.to_i == 200
  puts "Response: #{response.body}"
else
  puts "Request failed with status code: #{response.code}"
end

package main

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

func main() {
    url := "https://api.us.ascenda.com/api/users/id"
    
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Add("Accept", "application/json")
    req.Header.Add("Authorization", "Bearer ee6xxxxxxxxxxxxxxx598")
    req.Header.Add("X-Request-ID", "12345678-0000-0000-0000-000000000000")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error making request:", err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode == http.StatusOK {
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            fmt.Println("Error reading response:", err)
            return
        }
        fmt.Println("Response:", string(body))
    } else {
        fmt.Printf("Request failed with status code: %d\n", resp.StatusCode)
    }
}

import Foundation

let url = URL(string: "https://api.us.ascenda.com/api/users/id")!
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("application/json", forHTTPHeaderField: "Accept")
request.setValue("Bearer ee6xxxxxxxxxxxxxxx598", forHTTPHeaderField: "Authorization")
request.setValue("12345678-0000-0000-0000-000000000000", forHTTPHeaderField: "X-Request-ID")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, error == nil else {
        print("Error: \(error?.localizedDescription ?? "Unknown error")")
        return
    }

    if let httpResponse = response as? HTTPURLResponse {
        if httpResponse.statusCode == 200 {
            let responseString = String(data: data, encoding: .utf8)
            print("Response: \(responseString ?? "No response data")")
        } else {
            print("Request failed with status code: \(httpResponse.statusCode)")
        }
    }
}

task.resume()

import axios from 'axios';

const url = 'https://api.us.ascenda.com/api/users/id';

axios.get(url, {
    headers: {
        'Accept': 'application/json',
        'Authorization': 'Bearer ee6xxxxxxxxxxxxxxx598',
        'X-Request-ID': '12345678-0000-0000-0000-000000000000'
    }
})
.then(response => {
    console.log('Response:', response.data);
})
.catch(error => {
    if (error.response) {
        console.log('Request failed with status code:', error.response.status);
    } else {
        console.log('Error:', error.message);
    }
});

use reqwest::header::{ACCEPT, AUTHORIZATION, HeaderMap, HeaderValue};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let url = "https://api.us.ascenda.com/api/users/id";

    let mut headers = HeaderMap::new();
    headers.insert(ACCEPT, HeaderValue::from_static("application/json"));
    headers.insert(AUTHORIZATION, HeaderValue::from_static("Bearer ee6xxxxxxxxxxxxxxx598"));
    headers.insert("X-Request-ID", HeaderValue::from_static("12345678-0000-0000-0000-000000000000"));

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await?;

    if response.status().is_success() {
        let body = response.text().await?;
        println!("Response: {}", body);
    } else {
        println!("Request failed with status code: {}", response.status());
    }

    Ok(())
}