One endpoint, one object, nine errors.

# Python 3, standard library only. Run with JUPITERFETCH_API_KEY set: python3 brand.py
# http.client, not urllib.request: some networks block urllib's default client.
import http.client
import json
import os
import sys
import time
import urllib.parse

JUPITERFETCH_URL = "https://jupiterfetch.com/v1"


class JupiterFetchError(Exception):
    def __init__(self, status, problem):
        self.status, self.code, self.detail = status, problem["code"], problem["detail"]
        self.fetch_id = problem.get("fetchId")
        suffix = f" (fetchId {self.fetch_id})" if self.fetch_id else ""
        super().__init__(f"{self.code}: {self.detail}{suffix}")


def get_brand(domain, attempt=0):
    base = urllib.parse.urlsplit(JUPITERFETCH_URL)
    connect = http.client.HTTPSConnection if base.scheme == "https" else http.client.HTTPConnection
    conn = connect(base.netloc, timeout=70)  # a little over the longest wait the API allows
    key = os.environ.get("JUPITERFETCH_API_KEY", "")
    path = f"{base.path}/brands/{urllib.parse.quote(domain, safe='')}"
    conn.request("GET", path, headers={"Authorization": f"Bearer {key}"})
    res = conn.getresponse()
    body = res.read().decode()
    conn.close()
    if res.status == 200:
        return json.loads(body)  # a Brand object

    # Errors are RFC 9457 problem documents. Branch on "code", not on the status.
    if "application/problem+json" in res.getheader("Content-Type", ""):
        problem = json.loads(body)
    else:
        problem = {"code": "unknown", "detail": body}

    if attempt == 0 and problem["code"] == "fetch_timeout":
        # The fetch usually keeps running, so a retry often comes back from the cache.
        return get_brand(domain, 1)
    if attempt == 0 and problem["code"] == "rate_limited":
        # Wait out a short rate limit and retry once. A longer one is reported, not waited on.
        seconds = float(res.getheader("Retry-After", "1"))
        if seconds <= 10:
            time.sleep(seconds)
            return get_brand(domain, 1)

    raise JupiterFetchError(res.status, problem)


def main():
    try:
        brand = get_brand("stripe.com")
    except JupiterFetchError as err:
        sys.exit(str(err))
    except (OSError, http.client.HTTPException) as err:  # the API could not be reached
        sys.exit(f"network error: {err}")

    # logos is ranked best first and can be empty. Each source URL works for at least 30 days,
    # so download the file if you want to keep it.
    print("logo:", brand["logos"][0]["source"] if brand["logos"] else "none")
    # Lowercase hex such as "#1a2b3c", or None.
    print("primary color:", brand["colors"]["roles"]["primary"] or "none")


if __name__ == "__main__":
    main()

// Go, standard library only. Run with JUPITERFETCH_API_KEY set: go run brand.go
package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"time"
)

const jupiterFetchURL = "https://jupiterfetch.com/v1"

// client gives up a little after the longest wait the API allows.
var client = &http.Client{Timeout: 70 * time.Second}

// Brand holds only the fields this program reads. Add the ones you need.
type Brand struct {
	Logos []struct {
		Source string `json:"source"`
	} `json:"logos"`
	Colors struct {
		Roles struct {
			Primary *string `json:"primary"`
		} `json:"roles"`
	} `json:"colors"`
}

// Problem is an RFC 9457 problem document. Branch on Code, not on the status.
type Problem struct {
	Status  int    `json:"status"`
	Code    string `json:"code"`
	Detail  string `json:"detail"`
	FetchID string `json:"fetchId"`
}

func (p *Problem) Error() string {
	if p.FetchID != "" {
		return fmt.Sprintf("%s: %s (fetchId %s)", p.Code, p.Detail, p.FetchID)
	}
	return p.Code + ": " + p.Detail
}

func getBrand(domain string, attempt int) (*Brand, error) {
	req, err := http.NewRequest("GET", jupiterFetchURL+"/brands/"+url.PathEscape(domain), nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("JUPITERFETCH_API_KEY"))
	res, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	body, err := io.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}

	if res.StatusCode == http.StatusOK {
		var brand Brand
		if err := json.Unmarshal(body, &brand); err != nil {
			return nil, err
		}
		return &brand, nil
	}

	problem := &Problem{Status: res.StatusCode, Code: "unknown", Detail: string(body)}
	if strings.Contains(res.Header.Get("Content-Type"), "application/problem+json") {
		if err := json.Unmarshal(body, problem); err != nil {
			return nil, err
		}
	}
	if attempt == 0 && problem.Code == "fetch_timeout" {
		// The fetch usually keeps running, so a retry often comes back from the cache.
		return getBrand(domain, 1)
	}
	if attempt == 0 && problem.Code == "rate_limited" {
		// Wait out a short rate limit and retry once. A longer one is reported, not waited on.
		seconds, err := strconv.Atoi(res.Header.Get("Retry-After"))
		if err != nil {
			seconds = 1
		}
		if seconds <= 10 {
			time.Sleep(time.Duration(seconds) * time.Second)
			return getBrand(domain, 1)
		}
	}
	return nil, problem
}

func main() {
	brand, err := getBrand("stripe.com", 0)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	// logos is ranked best first and can be empty. Each source URL works for at least 30 days,
	// so download the file if you want to keep it.
	logo := "none"
	if len(brand.Logos) > 0 {
		logo = brand.Logos[0].Source
	}
	fmt.Println("logo:", logo)

	// Lowercase hex such as "#1a2b3c", or nil.
	primary := "none"
	if brand.Colors.Roles.Primary != nil {
		primary = *brand.Colors.Roles.Primary
	}
	fmt.Println("primary color:", primary)
}

<?php
// PHP 8, no extensions to install. Run with JUPITERFETCH_API_KEY set: php brand.php
const JUPITERFETCH_URL = 'https://jupiterfetch.com/v1';

final class JupiterFetchError extends RuntimeException
{
    public function __construct(public int $status, public array $problem)
    {
        $fetchId = isset($problem['fetchId']) ? " (fetchId {$problem['fetchId']})" : '';
        parent::__construct("{$problem['code']}: {$problem['detail']}$fetchId");
    }
}

function getBrand(string $domain, int $attempt = 0): array
{
    $context = stream_context_create(['http' => [
        'header' => 'Authorization: Bearer ' . getenv('JUPITERFETCH_API_KEY'),
        'ignore_errors' => true, // hand back the body of an error response, not false
        'follow_location' => 0, // one response, so the headers below are its own
        'timeout' => 70, // a little over the longest wait the API allows
    ]]);
    $stream = @fopen(JUPITERFETCH_URL . '/brands/' . rawurlencode($domain), 'r', false, $context);
    if ($stream === false) { // the API could not be reached
        throw new RuntimeException('network error: ' . (error_get_last()['message'] ?? 'no response'));
    }
    $meta = stream_get_meta_data($stream)['wrapper_data']; // the status line, then the headers
    $body = stream_get_contents($stream);
    fclose($stream);

    $status = (int) explode(' ', $meta[0])[1];
    $headers = [];
    foreach (array_slice($meta, 1) as $line) {
        [$name, $value] = explode(':', $line, 2);
        $headers[strtolower($name)] = trim($value);
    }
    if ($status === 200) {
        return json_decode($body, true); // a Brand object
    }

    // Errors are RFC 9457 problem documents. Branch on "code", not on the status.
    $problem = str_contains($headers['content-type'] ?? '', 'application/problem+json')
        ? json_decode($body, true)
        : ['code' => 'unknown', 'detail' => $body];

    if ($attempt === 0 && $problem['code'] === 'fetch_timeout') {
        // The fetch usually keeps running, so a retry often comes back from the cache.
        return getBrand($domain, 1);
    }
    if ($attempt === 0 && $problem['code'] === 'rate_limited') {
        // Wait out a short rate limit and retry once. A longer one is reported, not waited on.
        $seconds = (int) ($headers['retry-after'] ?? 1);
        if ($seconds <= 10) {
            sleep($seconds);
            return getBrand($domain, 1);
        }
    }

    throw new JupiterFetchError($status, $problem);
}

try {
    $brand = getBrand('stripe.com');
} catch (RuntimeException $e) {
    fwrite(STDERR, $e->getMessage() . PHP_EOL);
    exit(1);
}

// logos is ranked best first and can be empty. Each source URL works for at least 30 days,
// so download the file if you want to keep it.
echo 'logo: ', $brand['logos'][0]['source'] ?? 'none', PHP_EOL;
// Lowercase hex such as "#1a2b3c", or null.
echo 'primary color: ', $brand['colors']['roles']['primary'] ?? 'none', PHP_EOL;

# Ruby, standard library only. Run with JUPITERFETCH_API_KEY set: ruby brand.rb
require "erb"
require "json"
require "net/http"

JUPITERFETCH_URL = "https://jupiterfetch.com/v1"

class JupiterFetchError < StandardError
  attr_reader :status, :problem

  def initialize(status, problem)
    @status = status
    @problem = problem
    fetch_id = problem["fetchId"] ? " (fetchId #{problem["fetchId"]})" : ""
    super("#{problem["code"]}: #{problem["detail"]}#{fetch_id}")
  end
end

def get_brand(domain, attempt = 0)
  uri = URI("#{JUPITERFETCH_URL}/brands/#{ERB::Util.url_encode(domain)}")
  request = Net::HTTP::Get.new(uri)
  request["Authorization"] = "Bearer #{ENV.fetch("JUPITERFETCH_API_KEY", "")}"
  # A little over the longest wait the API allows, and no silent retries: those are below.
  options = { use_ssl: uri.scheme == "https", read_timeout: 70, max_retries: 0 }
  res = Net::HTTP.start(uri.host, uri.port, **options) { |http| http.request(request) }
  return JSON.parse(res.body) if res.is_a?(Net::HTTPSuccess) # a Brand object

  # Errors are RFC 9457 problem documents. Branch on "code", not on the status.
  problem =
    if res["Content-Type"].to_s.include?("application/problem+json")
      JSON.parse(res.body)
    else
      { "code" => "unknown", "detail" => res.body }
    end

  if attempt.zero? && problem["code"] == "fetch_timeout"
    # The fetch usually keeps running, so a retry often comes back from the cache.
    return get_brand(domain, 1)
  end
  if attempt.zero? && problem["code"] == "rate_limited"
    # Wait out a short rate limit and retry once. A longer one is reported, not waited on.
    seconds = (res["Retry-After"] || 1).to_f
    if seconds <= 10
      sleep(seconds)
      return get_brand(domain, 1)
    end
  end

  raise JupiterFetchError.new(res.code.to_i, problem)
end

begin
  brand = get_brand("stripe.com")
rescue JupiterFetchError => e
  abort(e.message)
rescue SocketError, SystemCallError, IOError, Timeout::Error, OpenSSL::SSL::SSLError => e
  abort("network error: #{e.message}") # the API could not be reached
end

# logos is ranked best first and can be empty. Each source URL works for at least 30 days,
# so download the file if you want to keep it.
logo = brand["logos"].first&.fetch("source") || "none"
puts "logo: #{logo}"
# Lowercase hex such as "#1a2b3c", or nil.
primary = brand.dig("colors", "roles", "primary") || "none"
puts "primary color: #{primary}"