API rate limits and quotas

#!/usr/bin/env bash
# Send a request, and when the API answers 429, wait as long as it asks and send it again.
# The call gives up after 10 seconds without a connection and after 30 seconds overall,
# so a stalled network can't hang the script.
set -euo pipefail

API="https://www.iminify.com/api/v1"

for attempt in 1 2 3 4 5; do
  status=$(curl -sS --connect-timeout 10 --max-time 30 -o response.json -D headers.txt -w '%{http_code}' "$API/account" \
    -H "Authorization: Bearer $IMINIFY_API_KEY" -H "Accept: application/json")

  if [ "$status" -lt 400 ]; then
    cat response.json
    exit 0
  fi

  if [ "$status" != "429" ]; then
    cat response.json >&2
    exit 1
  fi

  # A daily limit can ask for hours; decide whether your script should wait that long.
  wait=$(grep -i '^retry-after:' headers.txt | tr -dc '0-9' || true)
  sleep "${wait:-60}"
done

exit 1

"""Send a request, and when the API answers 429, wait as long as it asks and send it again.

Needs Python 3.8 or newer and the requests package (pip install requests).
"""
import os
import time

import requests

API = "https://www.iminify.com/api/v1"

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {os.environ['IMINIFY_API_KEY']}",
    "Accept": "application/json",
})


# requests waits forever by default. Each call gives up after 10 seconds without a
# connection and after 30 seconds without an answer; pass a longer timeout for a file.
def call(method, path, attempts=5, timeout=(10, 30), **kwargs):
    for _ in range(attempts):
        response = session.request(method, f"{API}{path}", timeout=timeout, **kwargs)

        if response.status_code != 429:
            response.raise_for_status()
            return response

        # A daily limit can ask for hours; decide whether your script should wait that long.
        time.sleep(int(response.headers.get("Retry-After", 60)))

    response.raise_for_status()


print(call("GET", "/account").json()["data"]["usage"])

<?php

declare(strict_types=1);

// Send a request, and when the API answers 429, wait as long as it asks and send it again.
// Needs PHP 8.1 or newer and Guzzle (composer require guzzlehttp/guzzle).

require __DIR__ . '/vendor/autoload.php';

use GuzzleHttp\Client;
use Psr\Http\Message\ResponseInterface;

// Guzzle waits forever by default. Each call gives up after 10 seconds without a
// connection and after 30 seconds overall; pass a longer 'timeout' for a file.
$client = new Client([
    'base_uri' => 'https://www.iminify.com/api/v1/',
    'connect_timeout' => 10,
    'timeout' => 30,
    'http_errors' => false,
    'headers' => [
        'Authorization' => 'Bearer ' . getenv('IMINIFY_API_KEY'),
        'Accept' => 'application/json',
    ],
]);

function call(Client $client, string $method, string $path, array $options = [], int $attempts = 5): ResponseInterface
{
    for ($attempt = 1; $attempt <= $attempts; $attempt++) {
        $response = $client->request($method, $path, $options);

        if (429 !== $response->getStatusCode()) {
            if ($response->getStatusCode() >= 400) {
                throw new RuntimeException($response->getStatusCode() . ': ' . json_decode((string) $response->getBody(), true)['message']);
            }

            return $response;
        }

        // A daily limit can ask for hours; decide whether your script should wait that long.
        sleep((int) ($response->getHeaderLine('Retry-After') ?: 60));
    }

    throw new RuntimeException('Still rate limited after every attempt');
}

$response = call($client, 'GET', 'account');

print_r(json_decode((string) $response->getBody(), true)['data']['usage']);

// Send a request, and when the API answers 429, wait as long as it asks and send it again.
// Needs Node 20 or newer. Save it as retry.mjs and run: node retry.mjs
import { setTimeout as sleep } from 'node:timers/promises';

const API = 'https://www.iminify.com/api/v1';

// Node's fetch waits up to five minutes on a stalled connection. Each call gives up
// after `seconds` instead; pass a longer one for a file.
const call = async (path, options = {}, attempts = 5, seconds = 30) => {
  for (let attempt = 1; attempt <= attempts; attempt++) {
    const response = await fetch(`${API}${path}`, {
      ...options,
      signal: AbortSignal.timeout(seconds * 1000),
      headers: {
        Authorization: `Bearer ${process.env.IMINIFY_API_KEY}`,
        Accept: 'application/json',
      },
    });

    if (response.status !== 429) {
      if (!response.ok) {
        throw new Error(`${response.status}: ${(await response.json()).message}`);
      }

      return response;
    }

    // A daily limit can ask for hours; decide whether your script should wait that long.
    await sleep(Number(response.headers.get('Retry-After') ?? 60) * 1000);
  }

  throw new Error('Still rate limited after every attempt');
};

console.log((await (await call('/account')).json()).data.usage);