Errors

curl -i "https://api.rankparse.com/v1/domain-authority?domain=github.com" \
  -H "X-API-Key: rp_your_key"
# Inspect the status line, then the JSON body's "code" field.

import os
import random
import time

import requests

API = "https://api.rankparse.com/v1"
HEADERS = {"X-API-Key": os.environ["RANKPARSE_API_KEY"]}

RETRYABLE = {"rate_limited", "query_timeout", "upstream_error", "psi_unavailable",
             "indexnow_unavailable", "timeout", "fetch_failed"}

class RankParseError(Exception):
    def __init__(self, status, code, message):
        super().__init__(f"{status} {code}: {message}")
        self.status, self.code, self.message = status, code, message

def call(path, params=None, max_attempts=4):
    for attempt in range(max_attempts):
        resp = requests.get(f"{API}{path}", params=params, headers=HEADERS, timeout=60)
        if resp.ok:
            return resp.json()

        try:
            body = resp.json()
        except ValueError:
            body = {}
        code = body.get("code", "unknown")
        message = body.get("message") or body.get("error", "")

        retryable = (code in RETRYABLE or resp.status_code in (500, 502, 503)) and body.get("retry") is not False
        if not retryable or attempt == max_attempts - 1:
            raise RankParseError(resp.status_code, code, message)

        # Honor retry_after when present, otherwise exponential backoff with jitter.
        delay = body.get("retry_after") or min(2 ** attempt, 30)
        if delay <= 300:  # do not sleep until tomorrow on a daily quota
            time.sleep(delay + random.random())
        else:
            raise RankParseError(resp.status_code, code, message)

try:
    print(call("/domain-authority", {"domain": "github.com"})["data"])
except RankParseError as err:
    if err.code == "insufficient_credits":
        print("Out of credits: https://rankparse.com/pricing")
    else:
        raise

const API = "https://api.rankparse.com/v1";
const HEADERS = { "X-API-Key": process.env.RANKPARSE_API_KEY };

const RETRYABLE = new Set([
  "rate_limited", "query_timeout", "upstream_error", "psi_unavailable",
  "indexnow_unavailable", "timeout", "fetch_failed",
]);

class RankParseError extends Error {
  constructor(status, code, message) {
    super(`${status} ${code}: ${message}`);
    this.status = status;
    this.code = code;
  }
}

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function call(path, params = {}, maxAttempts = 4) {
  const url = `${API}${path}?${new URLSearchParams(params)}`;
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const resp = await fetch(url, { headers: HEADERS });
    if (resp.ok) return resp.json();

    const body = await resp.json().catch(() => ({}));
    const code = body.code ?? "unknown";
    const message = body.message ?? body.error ?? "";

    const retryable =
      (RETRYABLE.has(code) || [500, 502, 503].includes(resp.status)) && body.retry !== false;
    const delay = body.retry_after ?? Math.min(2 ** attempt, 30);
    // Never sleep until tomorrow on a daily quota (retry_after can be hours).
    if (!retryable || attempt === maxAttempts - 1 || delay > 300) {
      throw new RankParseError(resp.status, code, message);
    }
    await sleep((delay + Math.random()) * 1000);
  }
}

try {
  const result = await call("/domain-authority", { domain: "github.com" });
  console.log(result.data);
} catch (err) {
  if (err.code === "insufficient_credits") {
    console.error("Out of credits: https://rankparse.com/pricing");
  } else {
    throw err;
  }
}