Rate limits

const BASE = "https://api.propsocket.io/v1";
const HEADERS = { Authorization: `Bearer ${process.env.PROPSOCKET_API_KEY}` };

async function get(path, params = {}) {
  const url = new URL(`${BASE}/${path}`);
  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, String(v));
  for (;;) {
    const resp = await fetch(url, { headers: HEADERS });
    if (resp.status === 429) {
      const wait = Number(resp.headers.get("Retry-After") ?? "1");
      await new Promise((r) => setTimeout(r, wait * 1000)); // honor the header
      continue;
    }
    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    return resp.json();
  }
}

console.log((await get("units", { limit: 100 })).meta);

package main

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

const base = "https://api.propsocket.io/v1"

func get(path string, params url.Values) map[string]any {
	key := os.Getenv("PROPSOCKET_API_KEY")
	for {
		req, _ := http.NewRequest("GET", base+"/"+path+"?"+params.Encode(), nil)
		req.Header.Set("Authorization", "Bearer "+key)
		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			panic(err)
		}
		if resp.StatusCode == 429 {
			wait, _ := strconv.Atoi(resp.Header.Get("Retry-After"))
			resp.Body.Close()
			time.Sleep(time.Duration(wait) * time.Second) // honor the header
			continue
		}
		if resp.StatusCode != 200 {
			resp.Body.Close()
			panic("HTTP " + strconv.Itoa(resp.StatusCode))
		}
		var body map[string]any
		json.NewDecoder(resp.Body).Decode(&body)
		resp.Body.Close()
		return body
	}
}

require "net/http"
require "json"
require "uri"

BASE = "https://api.propsocket.io/v1"
KEY = ENV.fetch("PROPSOCKET_API_KEY")

def get(path, **params)
  loop do
    uri = URI("#{BASE}/#{path}")
    uri.query = URI.encode_www_form(params)
    req = Net::HTTP::Get.new(uri)
    req["Authorization"] = "Bearer #{KEY}"
    res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
    if res.code.to_i == 429
      sleep(res["Retry-After"].to_i) # honor the server's wait, don't guess
      next
    end
    raise "HTTP #{res.code}" unless res.code.to_i == 200
    return JSON.parse(res.body)
  end
end

puts get("units", limit: 100)["meta"]

<?php
$base = "https://api.propsocket.io/v1";
$key  = getenv("PROPSOCKET_API_KEY");

function get(string $base, string $key, string $path, array $params): array
{
    while (true) {
        $ch = curl_init("$base/$path?" . http_build_query($params));
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HEADER => true,
            CURLOPT_HTTPHEADER => ["Authorization: Bearer $key"],
        ]);
        $raw = curl_exec($ch);
        $status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
        $headerSize = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
        $headers = substr($raw, 0, $headerSize);
        $payload = substr($raw, $headerSize);
        curl_close($ch);

        if ($status === 429) {
            preg_match("/retry-after:\s*(\d+)/i", $headers, $m);
            sleep((int) ($m[1] ?? 1)); // honor the header
            continue;
        }
        if ($status !== 200) {
            throw new RuntimeException("HTTP $status");
        }
        return json_decode($payload, true);
    }
}

print_r(get($base, $key, "units", ["limit" => 100])["meta"]);

import java.net.URI;
import java.net.http.*;
import com.fasterxml.jackson.databind.*; // Jackson: the one JSON dependency

var base = "https://api.propsocket.io/v1";
var key = System.getenv("PROPSOCKET_API_KEY");
var client = HttpClient.newHttpClient();
var mapper = new ObjectMapper();

JsonNode get(String path, String query) throws Exception {
    while (true) {
        var request = HttpRequest.newBuilder(URI.create(base + "/" + path + "?" + query))
                .header("Authorization", "Bearer " + key).build();
        var resp = client.send(request, HttpResponse.BodyHandlers.ofString());
        if (resp.statusCode() == 429) {
            int wait = resp.headers().firstValue("Retry-After")
                    .map(Integer::parseInt).orElse(1);
            Thread.sleep(wait * 1000L); // honor the header
            continue;
        }
        return mapper.readTree(resp.body());
    }
}

System.out.println(get("units", "limit=100").get("meta"));

using System.Text.Json;

var BASE = "https://api.propsocket.io/v1";
var key = Environment.GetEnvironmentVariable("PROPSOCKET_API_KEY");
using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", key);

async Task<JsonElement> Get(string path, string query)
{
    while (true)
    {
        var resp = await client.GetAsync($"{BASE}/{path}?{query}");
        if ((int)resp.StatusCode == 429)
        {
            var wait = resp.Headers.RetryAfter?.Delta?.TotalSeconds ?? 1;
            await Task.Delay(TimeSpan.FromSeconds(wait)); // honor the header
            continue;
        }
        resp.EnsureSuccessStatusCode();
        using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
        return doc.RootElement.Clone();
    }
}

Console.WriteLine((await Get("units", "limit=100")).GetProperty("meta"));